//// ASM: a very small and fast Java bytecode manipulation framework
//// Copyright (c) 2000-2011 INRIA, France Telecom
//// All rights reserved.
////
//// Redistribution and use in source and binary forms, with or without
//// modification, are permitted provided that the following conditions
//// are met:
//// 1. Redistributions of source code must retain the above copyright
////    notice, this list of conditions and the following disclaimer.
//// 2. Redistributions in binary form must reproduce the above copyright
////    notice, this list of conditions and the following disclaimer in the
////    documentation and/or other materials provided with the distribution.
//// 3. Neither the name of the copyright holders nor the names of its
////    contributors may be used to endorse or promote products derived from
////    this software without specific prior written permission.
////
//// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
//// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
//// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
//// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
//// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
//// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
//// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
//// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
//// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
//// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
//// THE POSSIBILITY OF SUCH DAMAGE.
//package com.lucky.utils.type;
//
//import java.io.ByteArrayOutputStream;
//import java.io.IOException;
//import java.io.InputStream;
//
///**
// * A parser to make a {@link ClassVisitor} visit a ClassFile structure, as defined in the Java
// * Virtual Machine Specification (JVMS). This class parses the ClassFile content and calls the
// * appropriate visit methods of a given {@link ClassVisitor} for each field, method and bytecode
// * instruction encountered.
// *
// * @see <a href="https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-4.html">JVMS 4</a>
// * @author Eric Bruneton
// * @author Eugene Kuleshov
// */
//public class ClassReader {
//
//    /**
//     * A flag to skip the Code attributes. If this flag is set the Code attributes are neither parsed
//     * nor visited.
//     */
//    public static final int SKIP_CODE = 1;
//
//    /**
//     * A flag to skip the SourceFile, SourceDebugExtension, LocalVariableTable,
//     * LocalVariableTypeTable, LineNumberTable and MethodParameters attributes. If this flag is set
//     * these attributes are neither parsed nor visited (i.e. {@link ClassVisitor#visitSource}, {@link
//     * MethodVisitor#visitLocalVariable}, {@link MethodVisitor#visitLineNumber} and {@link
//     * MethodVisitor#visitParameter} are not called).
//     */
//    public static final int SKIP_DEBUG = 2;
//
//    /**
//     * A flag to skip the StackMap and StackMapTable attributes. If this flag is set these attributes
//     * are neither parsed nor visited (i.e. {@link MethodVisitor#visitFrame} is not called). This flag
//     * is useful when the {@link ClassWriter#COMPUTE_FRAMES} option is used: it avoids visiting frames
//     * that will be ignored and recomputed from scratch.
//     */
//    public static final int SKIP_FRAMES = 4;
//
//    /**
//     * A flag to expand the stack map frames. By default stack map frames are visited in their
//     * original format (i.e. "expanded" for classes whose version is less than V1_6, and "compressed"
//     * for the other classes). If this flag is set, stack map frames are always visited in expanded
//     * format (this option adds a decompression/compression step in ClassReader and ClassWriter which
//     * degrades performance quite a lot).
//     */
//    public static final int EXPAND_FRAMES = 8;
//
//    /**
//     * A flag to expand the ASM specific instructions into an equivalent sequence of standard bytecode
//     * instructions. When resolving a forward jump it may happen that the signed 2 bytes offset
//     * reserved for it is not sufficient to store the bytecode offset. In this case the jump
//     * instruction is replaced with a temporary ASM specific instruction using an unsigned 2 bytes
//     * offset (see {@link Label#resolve}). This internal flag is used to re-read classes containing
//     * such instructions, in order to replace them with standard instructions. In addition, when this
//     * flag is used, goto_w and jsr_w are <i>not</i> converted into goto and jsr, to make sure that
//     * infinite loops where a goto_w is replaced with a goto in ClassReader and converted back to a
//     * goto_w in ClassWriter cannot occur.
//     */
//    static final int EXPAND_ASM_INSNS = 256;
//
//    /** The size of the temporary byte array used to read class input streams chunk by chunk. */
//    private static final int INPUT_STREAM_DATA_CHUNK_SIZE = 4096;
//
//    /**
//     * A byte array containing the JVMS ClassFile structure to be parsed.
//     *
//     * @deprecated Use {@link #readByte(int)} and the other read methods instead. This field will
//     *     eventually be deleted.
//     */
//    @Deprecated
//    // DontCheck(MemberName): can't be renamed (for backward binary compatibility).
//    public final byte[] b;
//
//    /**
//     * A byte array containing the JVMS ClassFile structure to be parsed. <i>The content of this array
//     * must not be modified. This field is intended for {@link Attribute} sub classes, and is normally
//     * not needed by class visitors.</i>
//     *
//     * <p>NOTE: the ClassFile structure can start at any offset within this array, i.e. it does not
//     * necessarily start at offset 0. Use {@link #getItem} and {@link #header} to get correct
//     * ClassFile element offsets within this byte array.
//     */
//    final byte[] classFileBuffer;
//
//    /**
//     * The offset in bytes, in {@link #classFileBuffer}, of each cp_info entry of the ClassFile's
//     * constant_pool array, <i>plus one</i>. In other words, the offset of constant pool entry i is
//     * given by cpInfoOffsets[i] - 1, i.e. its cp_info's tag field is given by b[cpInfoOffsets[i] -
//     * 1].
//     */
//    private final int[] cpInfoOffsets;
//
//    /**
//     * The String objects corresponding to the CONSTANT_Utf8 constant pool items. This cache avoids
//     * multiple parsing of a given CONSTANT_Utf8 constant pool item.
//     */
//    private final String[] constantUtf8Values;
//
//    /**
//     * The ConstantDynamic objects corresponding to the CONSTANT_Dynamic constant pool items. This
//     * cache avoids multiple parsing of a given CONSTANT_Dynamic constant pool item.
//     */
//    private final ConstantDynamic[] constantDynamicValues;
//
//    /**
//     * The start offsets in {@link #classFileBuffer} of each element of the bootstrap_methods array
//     * (in the BootstrapMethods attribute).
//     *
//     * @see <a href="https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-4.html#jvms-4.7.23">JVMS
//     *     4.7.23</a>
//     */
//    private final int[] bootstrapMethodOffsets;
//
//    /**
//     * A conservative estimate of the maximum length of the strings contained in the constant pool of
//     * the class.
//     */
//    private final int maxStringLength;
//
//    /** The offset in bytes of the ClassFile's access_flags field. */
//    public final int header;
//
//    // -----------------------------------------------------------------------------------------------
//    // Constructors
//    // -----------------------------------------------------------------------------------------------
//
//    /**
//     * Constructs a new {@link ClassReader} object.
//     *
//     * @param classFile the JVMS ClassFile structure to be read.
//     */
//    public ClassReader(final byte[] classFile) {
//        this(classFile, 0, classFile.length);
//    }
//
//    /**
//     * Constructs a new {@link ClassReader} object.
//     *
//     * @param classFileBuffer a byte array containing the JVMS ClassFile structure to be read.
//     * @param classFileOffset the offset in byteBuffer of the first byte of the ClassFile to be read.
//     * @param classFileLength the length in bytes of the ClassFile to be read.
//     */
//    public ClassReader(
//            final byte[] classFileBuffer,
//            final int classFileOffset,
//            final int classFileLength) { // NOPMD(UnusedFormalParameter) used for backward compatibility.
//        this(classFileBuffer, classFileOffset, /* checkClassVersion = */ true);
//    }
//
//    /**
//     * Constructs a new {@link ClassReader} object. <i>This internal constructor must not be exposed
//     * as a public API</i>.
//     *
//     * @param classFileBuffer a byte array containing the JVMS ClassFile structure to be read.
//     * @param classFileOffset the offset in byteBuffer of the first byte of the ClassFile to be read.
//     * @param checkClassVersion whether to check the class version or not.
//     */
//    ClassReader(
//            final byte[] classFileBuffer, final int classFileOffset, final boolean checkClassVersion) {
//        this.classFileBuffer = classFileBuffer;
//        this.b = classFileBuffer;
//        // Check the class' major_version. This field is after the magic and minor_version fields, which
//        // use 4 and 2 bytes respectively.
//        if (checkClassVersion && readShort(classFileOffset + 6) > Opcodes.V15) {
//            throw new IllegalArgumentException(
//                    "Unsupported class file major version " + readShort(classFileOffset + 6));
//        }
//        // Create the constant pool arrays. The constant_pool_count field is after the magic,
//        // minor_version and major_version fields, which use 4, 2 and 2 bytes respectively.
//        int constantPoolCount = readUnsignedShort(classFileOffset + 8);
//        cpInfoOffsets = new int[constantPoolCount];
//        constantUtf8Values = new String[constantPoolCount];
//        // Compute the offset of each constant pool entry, as well as a conservative estimate of the
//        // maximum length of the constant pool strings. The first constant pool entry is after the
//        // magic, minor_version, major_version and constant_pool_count fields, which use 4, 2, 2 and 2
//        // bytes respectively.
//        int currentCpInfoIndex = 1;
//        int currentCpInfoOffset = classFileOffset + 10;
//        int currentMaxStringLength = 0;
//        boolean hasBootstrapMethods = false;
//        boolean hasConstantDynamic = false;
//        // The offset of the other entries depend on the total size of all the previous entries.
//        while (currentCpInfoIndex < constantPoolCount) {
//            cpInfoOffsets[currentCpInfoIndex++] = currentCpInfoOffset + 1;
//            int cpInfoSize;
//            switch (classFileBuffer[currentCpInfoOffset]) {
//                case Symbol.CONSTANT_FIELDREF_TAG:
//                case Symbol.CONSTANT_METHODREF_TAG:
//                case Symbol.CONSTANT_INTERFACE_METHODREF_TAG:
//                case Symbol.CONSTANT_INTEGER_TAG:
//                case Symbol.CONSTANT_FLOAT_TAG:
//                case Symbol.CONSTANT_NAME_AND_TYPE_TAG:
//                    cpInfoSize = 5;
//                    break;
//                case Symbol.CONSTANT_DYNAMIC_TAG:
//                    cpInfoSize = 5;
//                    hasBootstrapMethods = true;
//                    hasConstantDynamic = true;
//                    break;
//                case Symbol.CONSTANT_INVOKE_DYNAMIC_TAG:
//                    cpInfoSize = 5;
//                    hasBootstrapMethods = true;
//                    break;
//                case Symbol.CONSTANT_LONG_TAG:
//                case Symbol.CONSTANT_DOUBLE_TAG:
//                    cpInfoSize = 9;
//                    currentCpInfoIndex++;
//                    break;
//                case Symbol.CONSTANT_UTF8_TAG:
//                    cpInfoSize = 3 + readUnsignedShort(currentCpInfoOffset + 1);
//                    if (cpInfoSize > currentMaxStringLength) {
//                        // The size in bytes of this CONSTANT_Utf8 structure provides a conservative estimate
//                        // of the length in characters of the corresponding string, and is much cheaper to
//                        // compute than this exact length.
//                        currentMaxStringLength = cpInfoSize;
//                    }
//                    break;
//                case Symbol.CONSTANT_METHOD_HANDLE_TAG:
//                    cpInfoSize = 4;
//                    break;
//                case Symbol.CONSTANT_CLASS_TAG:
//                case Symbol.CONSTANT_STRING_TAG:
//                case Symbol.CONSTANT_METHOD_TYPE_TAG:
//                case Symbol.CONSTANT_PACKAGE_TAG:
//                case Symbol.CONSTANT_MODULE_TAG:
//                    cpInfoSize = 3;
//                    break;
//                default:
//                    throw new IllegalArgumentException();
//            }
//            currentCpInfoOffset += cpInfoSize;
//        }
//        maxStringLength = currentMaxStringLength;
//        // The Classfile's access_flags field is just after the last constant pool entry.
//        header = currentCpInfoOffset;
//
//        // Allocate the cache of ConstantDynamic values, if there is at least one.
//        constantDynamicValues = hasConstantDynamic ? new ConstantDynamic[constantPoolCount] : null;
//
//        // Read the BootstrapMethods attribute, if any (only get the offset of each method).
//        bootstrapMethodOffsets =
//                hasBootstrapMethods ? readBootstrapMethodsAttribute(currentMaxStringLength) : null;
//    }
//
//    /**
//     * Constructs a new {@link ClassReader} object.
//     *
//     * @param inputStream an input stream of the JVMS ClassFile structure to be read. This input
//     *     stream must contain nothing more than the ClassFile structure itself. It is read from its
//     *     current position to its end.
//     * @throws IOException if a problem occurs during reading.
//     */
//    public ClassReader(final InputStream inputStream) throws IOException {
//        this(readStream(inputStream, false));
//    }
//
//    /**
//     * Constructs a new {@link ClassReader} object.
//     *
//     * @param className the fully qualified name of the class to be read. The ClassFile structure is
//     *     retrieved with the current class loader's {@link ClassLoader#getSystemResourceAsStream}.
//     * @throws IOException if an exception occurs during reading.
//     */
//    public ClassReader(final String className) throws IOException {
//        this(
//                readStream(
//                        ClassLoader.getSystemResourceAsStream(className.replace('.', '/') + ".class"), true));
//    }
//
//    /**
//     * Reads the given input stream and returns its content as a byte array.
//     *
//     * @param inputStream an input stream.
//     * @param close true to close the input stream after reading.
//     * @return the content of the given input stream.
//     * @throws IOException if a problem occurs during reading.
//     */
//    private static byte[] readStream(final InputStream inputStream, final boolean close)
//            throws IOException {
//        if (inputStream == null) {
//            throw new IOException("Class not found");
//        }
//        try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
//            byte[] data = new byte[INPUT_STREAM_DATA_CHUNK_SIZE];
//            int bytesRead;
//            while ((bytesRead = inputStream.read(data, 0, data.length)) != -1) {
//                outputStream.write(data, 0, bytesRead);
//            }
//            outputStream.flush();
//            return outputStream.toByteArray();
//        } finally {
//            if (close) {
//                inputStream.close();
//            }
//        }
//    }
//
//    // -----------------------------------------------------------------------------------------------
//    // Accessors
//    // -----------------------------------------------------------------------------------------------
//
//    /**
//     * Returns the class's access flags (see {@link Opcodes}). This value may not reflect Deprecated
//     * and Synthetic flags when bytecode is before 1.5 and those flags are represented by attributes.
//     *
//     * @return the class access flags.
//     * @see ClassVisitor#visit(int, int, String, String, String, String[])
//     */
//    public int getAccess() {
//        return readUnsignedShort(header);
//    }
//
//    /**
//     * Returns the internal name of the class (see {@link Type#getInternalName()}).
//     *
//     * @return the internal class name.
//     * @see ClassVisitor#visit(int, int, String, String, String, String[])
//     */
//    public String getClassName() {
//        // this_class is just after the access_flags field (using 2 bytes).
//        return readClass(header + 2, new char[maxStringLength]);
//    }
//
//    /**
//     * Returns the internal of name of the super class (see {@link Type#getInternalName()}). For
//     * interfaces, the super class is {@link Object}.
//     *
//     * @return the internal name of the super class, or {@literal null} for {@link Object} class.
//     * @see ClassVisitor#visit(int, int, String, String, String, String[])
//     */
//    public String getSuperName() {
//        // super_class is after the access_flags and this_class fields (2 bytes each).
//        return readClass(header + 4, new char[maxStringLength]);
//    }
//
//    /**
//     * Returns the internal names of the implemented interfaces (see {@link Type#getInternalName()}).
//     *
//     * @return the internal names of the directly implemented interfaces. Inherited implemented
//     *     interfaces are not returned.
//     * @see ClassVisitor#visit(int, int, String, String, String, String[])
//     */
//    public String[] getInterfaces() {
//        // interfaces_count is after the access_flags, this_class and super_class fields (2 bytes each).
//        int currentOffset = header + 6;
//        int interfacesCount = readUnsignedShort(currentOffset);
//        String[] interfaces = new String[interfacesCount];
//        if (interfacesCount > 0) {
//            char[] charBuffer = new char[maxStringLength];
//            for (int i = 0; i < interfacesCount; ++i) {
//                currentOffset += 2;
//                interfaces[i] = readClass(currentOffset, charBuffer);
//            }
//        }
//        return interfaces;
//    }
//
//    // -----------------------------------------------------------------------------------------------
//    // Public methods
//    // -----------------------------------------------------------------------------------------------
//
//    /**
//     * Makes the given visitor visit the JVMS ClassFile structure passed to the constructor of this
//     * {@link ClassReader}.
//     *
//     * @param classVisitor the visitor that must visit this class.
//     * @param parsingOptions the options to use to parse this class. One or more of {@link
//     *     #SKIP_CODE}, {@link #SKIP_DEBUG}, {@link #SKIP_FRAMES} or {@link #EXPAND_FRAMES}.
//     */
//    public void accept(final ClassVisitor classVisitor, final int parsingOptions) {
//        accept(classVisitor, new Attribute[0], parsingOptions);
//    }
//
//    /**
//     * Makes the given visitor visit the JVMS ClassFile structure passed to the constructor of this
//     * {@link ClassReader}.
//     *
//     * @param classVisitor the visitor that must visit this class.
//     * @param attributePrototypes prototypes of the attributes that must be parsed during the visit of
//     *     the class. Any attribute whose type is not equal to the type of one the prototypes will not
//     *     be parsed: its byte array value will be passed unchanged to the ClassWriter. <i>This may
//     *     corrupt it if this value contains references to the constant pool, or has syntactic or
//     *     semantic links with a class element that has been transformed by a class adapter between
//     *     the reader and the writer</i>.
//     * @param parsingOptions the options to use to parse this class. One or more of {@link
//     *     #SKIP_CODE}, {@link #SKIP_DEBUG}, {@link #SKIP_FRAMES} or {@link #EXPAND_FRAMES}.
//     */
//    @SuppressWarnings("deprecation")
//    public void accept(
//            final ClassVisitor classVisitor,
//            final Attribute[] attributePrototypes,
//            final int parsingOptions) {
//        Context context = new Context();
//        context.attributePrototypes = attributePrototypes;
//        context.parsingOptions = parsingOptions;
//        context.charBuffer = new char[maxStringLength];
//
//        // Read the access_flags, this_class, super_class, interface_count and interfaces fields.
//        char[] charBuffer = context.charBuffer;
//        int currentOffset = header;
//        int accessFlags = readUnsignedShort(currentOffset);
//        String thisClass = readClass(currentOffset + 2, charBuffer);
//        String superClass = readClass(currentOffset + 4, charBuffer);
//        String[] interfaces = new String[readUnsignedShort(currentOffset + 6)];
//        currentOffset += 8;
//        for (int i = 0; i < interfaces.length; ++i) {
//            interfaces[i] = readClass(currentOffset, charBuffer);
//            currentOffset += 2;
//        }
//
//        // Read the class attributes (the variables are ordered as in Section 4.7 of the JVMS).
//        // Attribute offsets exclude the attribute_name_index and attribute_length fields.
//        // - The offset of the InnerClasses attribute, or 0.
//        int innerClassesOffset = 0;
//        // - The offset of the EnclosingMethod attribute, or 0.
//        int enclosingMethodOffset = 0;
//        // - The string corresponding to the Signature attribute, or null.
//        String signature = null;
//        // - The string corresponding to the SourceFile attribute, or null.
//        String sourceFile = null;
//        // - The string corresponding to the SourceDebugExtension attribute, or null.
//        String sourceDebugExtension = null;
//        // - The offset of the RuntimeVisibleAnnotations attribute, or 0.
//        int runtimeVisibleAnnotationsOffset = 0;
//        // - The offset of the RuntimeInvisibleAnnotations attribute, or 0.
//        int runtimeInvisibleAnnotationsOffset = 0;
//        // - The offset of the RuntimeVisibleTypeAnnotations attribute, or 0.
//        int runtimeVisibleTypeAnnotationsOffset = 0;
//        // - The offset of the RuntimeInvisibleTypeAnnotations attribute, or 0.
//        int runtimeInvisibleTypeAnnotationsOffset = 0;
//        // - The offset of the Module attribute, or 0.
//        int moduleOffset = 0;
//        // - The offset of the ModulePackages attribute, or 0.
//        int modulePackagesOffset = 0;
//        // - The string corresponding to the ModuleMainClass attribute, or null.
//        String moduleMainClass = null;
//        // - The string corresponding to the NestHost attribute, or null.
//        String nestHostClass = null;
//        // - The offset of the NestMembers attribute, or 0.
//        int nestMembersOffset = 0;
//        // - The offset of the PermittedSubtypes attribute, or 0
//        int permittedSubtypesOffset = 0;
//        // - The offset of the Record attribute, or 0.
//        int recordOffset = 0;
//        // - The non standard attributes (linked with their {@link Attribute#nextAttribute} field).
//        //   This list in the <i>reverse order</i> or their order in the ClassFile structure.
//        Attribute attributes = null;
//
//        int currentAttributeOffset = getFirstAttributeOffset();
//        for (int i = readUnsignedShort(currentAttributeOffset - 2); i > 0; --i) {
//            // Read the attribute_info's attribute_name and attribute_length fields.
//            String attributeName = readUTF8(currentAttributeOffset, charBuffer);
//            int attributeLength = readInt(currentAttributeOffset + 2);
//            currentAttributeOffset += 6;
//            // The tests are sorted in decreasing frequency order (based on frequencies observed on
//            // typical classes).
//            if (Constants.SOURCE_FILE.equals(attributeName)) {
//                sourceFile = readUTF8(currentAttributeOffset, charBuffer);
//            } else if (Constants.INNER_CLASSES.equals(attributeName)) {
//                innerClassesOffset = currentAttributeOffset;
//            } else if (Constants.ENCLOSING_METHOD.equals(attributeName)) {
//                enclosingMethodOffset = currentAttributeOffset;
//            } else if (Constants.NEST_HOST.equals(attributeName)) {
//                nestHostClass = readClass(currentAttributeOffset, charBuffer);
//            } else if (Constants.NEST_MEMBERS.equals(attributeName)) {
//                nestMembersOffset = currentAttributeOffset;
//            } else if (Constants.PERMITTED_SUBTYPES.equals(attributeName)) {
//                permittedSubtypesOffset = currentAttributeOffset;
//            } else if (Constants.SIGNATURE.equals(attributeName)) {
//                signature = readUTF8(currentAttributeOffset, charBuffer);
//            } else if (Constants.RUNTIME_VISIBLE_ANNOTATIONS.equals(attributeName)) {
//                runtimeVisibleAnnotationsOffset = currentAttributeOffset;
//            } else if (Constants.RUNTIME_VISIBLE_TYPE_ANNOTATIONS.equals(attributeName)) {
//                runtimeVisibleTypeAnnotationsOffset = currentAttributeOffset;
//            } else if (Constants.DEPRECATED.equals(attributeName)) {
//                accessFlags |= Opcodes.ACC_DEPRECATED;
//            } else if (Constants.SYNTHETIC.equals(attributeName)) {
//                accessFlags |= Opcodes.ACC_SYNTHETIC;
//            } else if (Constants.SOURCE_DEBUG_EXTENSION.equals(attributeName)) {
//                sourceDebugExtension =
//                        readUtf(currentAttributeOffset, attributeLength, new char[attributeLength]);
//            } else if (Constants.RUNTIME_INVISIBLE_ANNOTATIONS.equals(attributeName)) {
//                runtimeInvisibleAnnotationsOffset = currentAttributeOffset;
//            } else if (Constants.RUNTIME_INVISIBLE_TYPE_ANNOTATIONS.equals(attributeName)) {
//                runtimeInvisibleTypeAnnotationsOffset = currentAttributeOffset;
//            } else if (Constants.RECORD.equals(attributeName)) {
//                recordOffset = currentAttributeOffset;
//            } else if (Constants.MODULE.equals(attributeName)) {
//                moduleOffset = currentAttributeOffset;
//            } else if (Constants.MODULE_MAIN_CLASS.equals(attributeName)) {
//                moduleMainClass = readClass(currentAttributeOffset, charBuffer);
//            } else if (Constants.MODULE_PACKAGES.equals(attributeName)) {
//                modulePackagesOffset = currentAttributeOffset;
//            } else if (!Constants.BOOTSTRAP_METHODS.equals(attributeName)) {
//                // The BootstrapMethods attribute is read in the constructor.
//                Attribute attribute =
//                        readAttribute(
//                                attributePrototypes,
//                                attributeName,
//                                currentAttributeOffset,
//                                attributeLength,
//                                charBuffer,
//                                -1,
//                                null);
//                attribute.nextAttribute = attributes;
//                attributes = attribute;
//            }
//            currentAttributeOffset += attributeLength;
//        }
//
//        // Visit the class declaration. The minor_version and major_version fields start 6 bytes before
//        // the first constant pool entry, which itself starts at cpInfoOffsets[1] - 1 (by definition).
//        classVisitor.visit(
//                readInt(cpInfoOffsets[1] - 7), accessFlags, thisClass, signature, superClass, interfaces);
//
//        // Visit the SourceFile and SourceDebugExtenstion attributes.
//        if ((parsingOptions & SKIP_DEBUG) == 0
//                && (sourceFile != null || sourceDebugExtension != null)) {
//            classVisitor.visitSource(sourceFile, sourceDebugExtension);
//        }
//
//        // Visit the Module, ModulePackages and ModuleMainClass attributes.
//        if (moduleOffset != 0) {
//            readModuleAttributes(
//                    classVisitor, context, moduleOffset, modulePackagesOffset, moduleMainClass);
//        }
//
//        // Visit the NestHost attribute.
//        if (nestHostClass != null) {
//            classVisitor.visitNestHost(nestHostClass);
//        }
//
//        // Visit the EnclosingMethod attribute.
//        if (enclosingMethodOffset != 0) {
//            String className = readClass(enclosingMethodOffset, charBuffer);
//            int methodIndex = readUnsignedShort(enclosingMethodOffset + 2);
//            String name = methodIndex == 0 ? null : readUTF8(cpInfoOffsets[methodIndex], charBuffer);
//            String type = methodIndex == 0 ? null : readUTF8(cpInfoOffsets[methodIndex] + 2, charBuffer);
//            classVisitor.visitOuterClass(className, name, type);
//        }
//
//        // Visit the RuntimeVisibleAnnotations attribute.
//        if (runtimeVisibleAnnotationsOffset != 0) {
//            int numAnnotations = readUnsignedShort(runtimeVisibleAnnotationsOffset);
//            int currentAnnotationOffset = runtimeVisibleAnnotationsOffset + 2;
//            while (numAnnotations-- > 0) {
//                // Parse the type_index field.
//                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
//                currentAnnotationOffset += 2;
//                // Parse num_element_value_pairs and element_value_pairs and visit these values.
//                currentAnnotationOffset =
//                        readElementValues(
//                                classVisitor.visitAnnotation(annotationDescriptor, /* visible = */ true),
//                                currentAnnotationOffset,
//                                /* named = */ true,
//                                charBuffer);
//            }
//        }
//
//        // Visit the RuntimeInvisibleAnnotations attribute.
//        if (runtimeInvisibleAnnotationsOffset != 0) {
//            int numAnnotations = readUnsignedShort(runtimeInvisibleAnnotationsOffset);
//            int currentAnnotationOffset = runtimeInvisibleAnnotationsOffset + 2;
//            while (numAnnotations-- > 0) {
//                // Parse the type_index field.
//                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
//                currentAnnotationOffset += 2;
//                // Parse num_element_value_pairs and element_value_pairs and visit these values.
//                currentAnnotationOffset =
//                        readElementValues(
//                                classVisitor.visitAnnotation(annotationDescriptor, /* visible = */ false),
//                                currentAnnotationOffset,
//                                /* named = */ true,
//                                charBuffer);
//            }
//        }
//
//        // Visit the RuntimeVisibleTypeAnnotations attribute.
//        if (runtimeVisibleTypeAnnotationsOffset != 0) {
//            int numAnnotations = readUnsignedShort(runtimeVisibleTypeAnnotationsOffset);
//            int currentAnnotationOffset = runtimeVisibleTypeAnnotationsOffset + 2;
//            while (numAnnotations-- > 0) {
//                // Parse the target_type, target_info and target_path fields.
//                currentAnnotationOffset = readTypeAnnotationTarget(context, currentAnnotationOffset);
//                // Parse the type_index field.
//                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
//                currentAnnotationOffset += 2;
//                // Parse num_element_value_pairs and element_value_pairs and visit these values.
//                currentAnnotationOffset =
//                        readElementValues(
//                                classVisitor.visitTypeAnnotation(
//                                        context.currentTypeAnnotationTarget,
//                                        context.currentTypeAnnotationTargetPath,
//                                        annotationDescriptor,
//                                        /* visible = */ true),
//                                currentAnnotationOffset,
//                                /* named = */ true,
//                                charBuffer);
//            }
//        }
//
//        // Visit the RuntimeInvisibleTypeAnnotations attribute.
//        if (runtimeInvisibleTypeAnnotationsOffset != 0) {
//            int numAnnotations = readUnsignedShort(runtimeInvisibleTypeAnnotationsOffset);
//            int currentAnnotationOffset = runtimeInvisibleTypeAnnotationsOffset + 2;
//            while (numAnnotations-- > 0) {
//                // Parse the target_type, target_info and target_path fields.
//                currentAnnotationOffset = readTypeAnnotationTarget(context, currentAnnotationOffset);
//                // Parse the type_index field.
//                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
//                currentAnnotationOffset += 2;
//                // Parse num_element_value_pairs and element_value_pairs and visit these values.
//                currentAnnotationOffset =
//                        readElementValues(
//                                classVisitor.visitTypeAnnotation(
//                                        context.currentTypeAnnotationTarget,
//                                        context.currentTypeAnnotationTargetPath,
//                                        annotationDescriptor,
//                                        /* visible = */ false),
//                                currentAnnotationOffset,
//                                /* named = */ true,
//                                charBuffer);
//            }
//        }
//
//        // Visit the non standard attributes.
//        while (attributes != null) {
//            // Copy and reset the nextAttribute field so that it can also be used in ClassWriter.
//            Attribute nextAttribute = attributes.nextAttribute;
//            attributes.nextAttribute = null;
//            classVisitor.visitAttribute(attributes);
//            attributes = nextAttribute;
//        }
//
//        // Visit the NestedMembers attribute.
//        if (nestMembersOffset != 0) {
//            int numberOfNestMembers = readUnsignedShort(nestMembersOffset);
//            int currentNestMemberOffset = nestMembersOffset + 2;
//            while (numberOfNestMembers-- > 0) {
//                classVisitor.visitNestMember(readClass(currentNestMemberOffset, charBuffer));
//                currentNestMemberOffset += 2;
//            }
//        }
//
//        // Visit the PermittedSubtypes attribute.
//        if (permittedSubtypesOffset != 0) {
//            int numberOfPermittedSubtypes = readUnsignedShort(permittedSubtypesOffset);
//            int currentPermittedSubtypeOffset = permittedSubtypesOffset + 2;
//            while (numberOfPermittedSubtypes-- > 0) {
//                classVisitor.visitPermittedSubtypeExperimental(
//                        readClass(currentPermittedSubtypeOffset, charBuffer));
//                currentPermittedSubtypeOffset += 2;
//            }
//        }
//
//        // Visit the InnerClasses attribute.
//        if (innerClassesOffset != 0) {
//            int numberOfClasses = readUnsignedShort(innerClassesOffset);
//            int currentClassesOffset = innerClassesOffset + 2;
//            while (numberOfClasses-- > 0) {
//                classVisitor.visitInnerClass(
//                        readClass(currentClassesOffset, charBuffer),
//                        readClass(currentClassesOffset + 2, charBuffer),
//                        readUTF8(currentClassesOffset + 4, charBuffer),
//                        readUnsignedShort(currentClassesOffset + 6));
//                currentClassesOffset += 8;
//            }
//        }
//
//        // Visit Record components.
//        if (recordOffset != 0) {
//            int recordComponentsCount = readUnsignedShort(recordOffset);
//            recordOffset += 2;
//            while (recordComponentsCount-- > 0) {
//                recordOffset = readRecordComponent(classVisitor, context, recordOffset);
//            }
//        }
//
//        // Visit the fields and methods.
//        int fieldsCount = readUnsignedShort(currentOffset);
//        currentOffset += 2;
//        while (fieldsCount-- > 0) {
//            currentOffset = readField(classVisitor, context, currentOffset);
//        }
//        int methodsCount = readUnsignedShort(currentOffset);
//        currentOffset += 2;
//        while (methodsCount-- > 0) {
//            currentOffset = readMethod(classVisitor, context, currentOffset);
//        }
//
//        // Visit the end of the class.
//        classVisitor.visitEnd();
//    }
//
//    // ----------------------------------------------------------------------------------------------
//    // Methods to parse modules, fields and methods
//    // ----------------------------------------------------------------------------------------------
//
//    /**
//     * Reads the Module, ModulePackages and ModuleMainClass attributes and visit them.
//     *
//     * @param classVisitor the current class visitor
//     * @param context information about the class being parsed.
//     * @param moduleOffset the offset of the Module attribute (excluding the attribute_info's
//     *     attribute_name_index and attribute_length fields).
//     * @param modulePackagesOffset the offset of the ModulePackages attribute (excluding the
//     *     attribute_info's attribute_name_index and attribute_length fields), or 0.
//     * @param moduleMainClass the string corresponding to the ModuleMainClass attribute, or {@literal
//     *     null}.
//     */
//    private void readModuleAttributes(
//            final ClassVisitor classVisitor,
//            final Context context,
//            final int moduleOffset,
//            final int modulePackagesOffset,
//            final String moduleMainClass) {
//        char[] buffer = context.charBuffer;
//
//        // Read the module_name_index, module_flags and module_version_index fields and visit them.
//        int currentOffset = moduleOffset;
//        String moduleName = readModule(currentOffset, buffer);
//        int moduleFlags = readUnsignedShort(currentOffset + 2);
//        String moduleVersion = readUTF8(currentOffset + 4, buffer);
//        currentOffset += 6;
//        ModuleVisitor moduleVisitor = classVisitor.visitModule(moduleName, moduleFlags, moduleVersion);
//        if (moduleVisitor == null) {
//            return;
//        }
//
//        // Visit the ModuleMainClass attribute.
//        if (moduleMainClass != null) {
//            moduleVisitor.visitMainClass(moduleMainClass);
//        }
//
//        // Visit the ModulePackages attribute.
//        if (modulePackagesOffset != 0) {
//            int packageCount = readUnsignedShort(modulePackagesOffset);
//            int currentPackageOffset = modulePackagesOffset + 2;
//            while (packageCount-- > 0) {
//                moduleVisitor.visitPackage(readPackage(currentPackageOffset, buffer));
//                currentPackageOffset += 2;
//            }
//        }
//
//        // Read the 'requires_count' and 'requires' fields.
//        int requiresCount = readUnsignedShort(currentOffset);
//        currentOffset += 2;
//        while (requiresCount-- > 0) {
//            // Read the requires_index, requires_flags and requires_version fields and visit them.
//            String requires = readModule(currentOffset, buffer);
//            int requiresFlags = readUnsignedShort(currentOffset + 2);
//            String requiresVersion = readUTF8(currentOffset + 4, buffer);
//            currentOffset += 6;
//            moduleVisitor.visitRequire(requires, requiresFlags, requiresVersion);
//        }
//
//        // Read the 'exports_count' and 'exports' fields.
//        int exportsCount = readUnsignedShort(currentOffset);
//        currentOffset += 2;
//        while (exportsCount-- > 0) {
//            // Read the exports_index, exports_flags, exports_to_count and exports_to_index fields
//            // and visit them.
//            String exports = readPackage(currentOffset, buffer);
//            int exportsFlags = readUnsignedShort(currentOffset + 2);
//            int exportsToCount = readUnsignedShort(currentOffset + 4);
//            currentOffset += 6;
//            String[] exportsTo = null;
//            if (exportsToCount != 0) {
//                exportsTo = new String[exportsToCount];
//                for (int i = 0; i < exportsToCount; ++i) {
//                    exportsTo[i] = readModule(currentOffset, buffer);
//                    currentOffset += 2;
//                }
//            }
//            moduleVisitor.visitExport(exports, exportsFlags, exportsTo);
//        }
//
//        // Reads the 'opens_count' and 'opens' fields.
//        int opensCount = readUnsignedShort(currentOffset);
//        currentOffset += 2;
//        while (opensCount-- > 0) {
//            // Read the opens_index, opens_flags, opens_to_count and opens_to_index fields and visit them.
//            String opens = readPackage(currentOffset, buffer);
//            int opensFlags = readUnsignedShort(currentOffset + 2);
//            int opensToCount = readUnsignedShort(currentOffset + 4);
//            currentOffset += 6;
//            String[] opensTo = null;
//            if (opensToCount != 0) {
//                opensTo = new String[opensToCount];
//                for (int i = 0; i < opensToCount; ++i) {
//                    opensTo[i] = readModule(currentOffset, buffer);
//                    currentOffset += 2;
//                }
//            }
//            moduleVisitor.visitOpen(opens, opensFlags, opensTo);
//        }
//
//        // Read the 'uses_count' and 'uses' fields.
//        int usesCount = readUnsignedShort(currentOffset);
//        currentOffset += 2;
//        while (usesCount-- > 0) {
//            moduleVisitor.visitUse(readClass(currentOffset, buffer));
//            currentOffset += 2;
//        }
//
//        // Read the  'provides_count' and 'provides' fields.
//        int providesCount = readUnsignedShort(currentOffset);
//        currentOffset += 2;
//        while (providesCount-- > 0) {
//            // Read the provides_index, provides_with_count and provides_with_index fields and visit them.
//            String provides = readClass(currentOffset, buffer);
//            int providesWithCount = readUnsignedShort(currentOffset + 2);
//            currentOffset += 4;
//            String[] providesWith = new String[providesWithCount];
//            for (int i = 0; i < providesWithCount; ++i) {
//                providesWith[i] = readClass(currentOffset, buffer);
//                currentOffset += 2;
//            }
//            moduleVisitor.visitProvide(provides, providesWith);
//        }
//
//        // Visit the end of the module attributes.
//        moduleVisitor.visitEnd();
//    }
//
//    /**
//     * Reads a record component and visit it.
//     *
//     * @param classVisitor the current class visitor
//     * @param context information about the class being parsed.
//     * @param recordComponentOffset the offset of the current record component.
//     * @return the offset of the first byte following the record component.
//     */
//    @SuppressWarnings("deprecation")
//    private int readRecordComponent(
//            final ClassVisitor classVisitor, final Context context, final int recordComponentOffset) {
//        char[] charBuffer = context.charBuffer;
//
//        int currentOffset = recordComponentOffset;
//        String name = readUTF8(currentOffset, charBuffer);
//        String descriptor = readUTF8(currentOffset + 2, charBuffer);
//        currentOffset += 4;
//
//        // Read the record component attributes (the variables are ordered as in Section 4.7 of the
//        // JVMS).
//
//        int accessFlags = 0;
//        // Attribute offsets exclude the attribute_name_index and attribute_length fields.
//        // - The string corresponding to the Signature attribute, or null.
//        String signature = null;
//        // - The offset of the RuntimeVisibleAnnotations attribute, or 0.
//        int runtimeVisibleAnnotationsOffset = 0;
//        // - The offset of the RuntimeInvisibleAnnotations attribute, or 0.
//        int runtimeInvisibleAnnotationsOffset = 0;
//        // - The offset of the RuntimeVisibleTypeAnnotations attribute, or 0.
//        int runtimeVisibleTypeAnnotationsOffset = 0;
//        // - The offset of the RuntimeInvisibleTypeAnnotations attribute, or 0.
//        int runtimeInvisibleTypeAnnotationsOffset = 0;
//        // - The non standard attributes (linked with their {@link Attribute#nextAttribute} field).
//        //   This list in the <i>reverse order</i> or their order in the ClassFile structure.
//        Attribute attributes = null;
//
//        int attributesCount = readUnsignedShort(currentOffset);
//        currentOffset += 2;
//        while (attributesCount-- > 0) {
//            // Read the attribute_info's attribute_name and attribute_length fields.
//            String attributeName = readUTF8(currentOffset, charBuffer);
//            int attributeLength = readInt(currentOffset + 2);
//            currentOffset += 6;
//            // The tests are sorted in decreasing frequency order (based on frequencies observed on
//            // typical classes).
//            if (Constants.SIGNATURE.equals(attributeName)) {
//                signature = readUTF8(currentOffset, charBuffer);
//            } else if (Constants.DEPRECATED.equals(attributeName)) {
//                accessFlags |= Opcodes.ACC_DEPRECATED;
//            } else if (Constants.RUNTIME_VISIBLE_ANNOTATIONS.equals(attributeName)) {
//                runtimeVisibleAnnotationsOffset = currentOffset;
//            } else if (Constants.RUNTIME_VISIBLE_TYPE_ANNOTATIONS.equals(attributeName)) {
//                runtimeVisibleTypeAnnotationsOffset = currentOffset;
//            } else if (Constants.RUNTIME_INVISIBLE_ANNOTATIONS.equals(attributeName)) {
//                runtimeInvisibleAnnotationsOffset = currentOffset;
//            } else if (Constants.RUNTIME_INVISIBLE_TYPE_ANNOTATIONS.equals(attributeName)) {
//                runtimeInvisibleTypeAnnotationsOffset = currentOffset;
//            } else {
//                Attribute attribute =
//                        readAttribute(
//                                context.attributePrototypes,
//                                attributeName,
//                                currentOffset,
//                                attributeLength,
//                                charBuffer,
//                                -1,
//                                null);
//                attribute.nextAttribute = attributes;
//                attributes = attribute;
//            }
//            currentOffset += attributeLength;
//        }
//
//        RecordComponentVisitor recordComponentVisitor =
//                classVisitor.visitRecordComponentExperimental(accessFlags, name, descriptor, signature);
//        if (recordComponentVisitor == null) {
//            return currentOffset;
//        }
//
//        // Visit the RuntimeVisibleAnnotations attribute.
//        if (runtimeVisibleAnnotationsOffset != 0) {
//            int numAnnotations = readUnsignedShort(runtimeVisibleAnnotationsOffset);
//            int currentAnnotationOffset = runtimeVisibleAnnotationsOffset + 2;
//            while (numAnnotations-- > 0) {
//                // Parse the type_index field.
//                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
//                currentAnnotationOffset += 2;
//                // Parse num_element_value_pairs and element_value_pairs and visit these values.
//                currentAnnotationOffset =
//                        readElementValues(
//                                recordComponentVisitor.visitAnnotationExperimental(
//                                        annotationDescriptor, /* visible = */ true),
//                                currentAnnotationOffset,
//                                /* named = */ true,
//                                charBuffer);
//            }
//        }
//
//        // Visit the RuntimeInvisibleAnnotations attribute.
//        if (runtimeInvisibleAnnotationsOffset != 0) {
//            int numAnnotations = readUnsignedShort(runtimeInvisibleAnnotationsOffset);
//            int currentAnnotationOffset = runtimeInvisibleAnnotationsOffset + 2;
//            while (numAnnotations-- > 0) {
//                // Parse the type_index field.
//                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
//                currentAnnotationOffset += 2;
//                // Parse num_element_value_pairs and element_value_pairs and visit these values.
//                currentAnnotationOffset =
//                        readElementValues(
//                                recordComponentVisitor.visitAnnotationExperimental(
//                                        annotationDescriptor, /* visible = */ false),
//                                currentAnnotationOffset,
//                                /* named = */ true,
//                                charBuffer);
//            }
//        }
//
//        // Visit the RuntimeVisibleTypeAnnotations attribute.
//        if (runtimeVisibleTypeAnnotationsOffset != 0) {
//            int numAnnotations = readUnsignedShort(runtimeVisibleTypeAnnotationsOffset);
//            int currentAnnotationOffset = runtimeVisibleTypeAnnotationsOffset + 2;
//            while (numAnnotations-- > 0) {
//                // Parse the target_type, target_info and target_path fields.
//                currentAnnotationOffset = readTypeAnnotationTarget(context, currentAnnotationOffset);
//                // Parse the type_index field.
//                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
//                currentAnnotationOffset += 2;
//                // Parse num_element_value_pairs and element_value_pairs and visit these values.
//                currentAnnotationOffset =
//                        readElementValues(
//                                recordComponentVisitor.visitTypeAnnotationExperimental(
//                                        context.currentTypeAnnotationTarget,
//                                        context.currentTypeAnnotationTargetPath,
//                                        annotationDescriptor,
//                                        /* visible = */ true),
//                                currentAnnotationOffset,
//                                /* named = */ true,
//                                charBuffer);
//            }
//        }
//
//        // Visit the RuntimeInvisibleTypeAnnotations attribute.
//        if (runtimeInvisibleTypeAnnotationsOffset != 0) {
//            int numAnnotations = readUnsignedShort(runtimeInvisibleTypeAnnotationsOffset);
//            int currentAnnotationOffset = runtimeInvisibleTypeAnnotationsOffset + 2;
//            while (numAnnotations-- > 0) {
//                // Parse the target_type, target_info and target_path fields.
//                currentAnnotationOffset = readTypeAnnotationTarget(context, currentAnnotationOffset);
//                // Parse the type_index field.
//                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
//                currentAnnotationOffset += 2;
//                // Parse num_element_value_pairs and element_value_pairs and visit these values.
//                currentAnnotationOffset =
//                        readElementValues(
//                                recordComponentVisitor.visitTypeAnnotationExperimental(
//                                        context.currentTypeAnnotationTarget,
//                                        context.currentTypeAnnotationTargetPath,
//                                        annotationDescriptor,
//                                        /* visible = */ false),
//                                currentAnnotationOffset,
//                                /* named = */ true,
//                                charBuffer);
//            }
//        }
//
//        // Visit the non standard attributes.
//        while (attributes != null) {
//            // Copy and reset the nextAttribute field so that it can also be used in FieldWriter.
//            Attribute nextAttribute = attributes.nextAttribute;
//            attributes.nextAttribute = null;
//            recordComponentVisitor.visitAttributeExperimental(attributes);
//            attributes = nextAttribute;
//        }
//
//        // Visit the end of the field.
//        recordComponentVisitor.visitEndExperimental();
//        return currentOffset;
//    }
//
//    /**
//     * Reads a JVMS field_info structure and makes the given visitor visit it.
//     *
//     * @param classVisitor the visitor that must visit the field.
//     * @param context information about the class being parsed.
//     * @param fieldInfoOffset the start offset of the field_info structure.
//     * @return the offset of the first byte following the field_info structure.
//     */
//    private int readField(
//            final ClassVisitor classVisitor, final Context context, final int fieldInfoOffset) {
//        char[] charBuffer = context.charBuffer;
//
//        // Read the access_flags, name_index and descriptor_index fields.
//        int currentOffset = fieldInfoOffset;
//        int accessFlags = readUnsignedShort(currentOffset);
//        String name = readUTF8(currentOffset + 2, charBuffer);
//        String descriptor = readUTF8(currentOffset + 4, charBuffer);
//        currentOffset += 6;
//
//        // Read the field attributes (the variables are ordered as in Section 4.7 of the JVMS).
//        // Attribute offsets exclude the attribute_name_index and attribute_length fields.
//        // - The value corresponding to the ConstantValue attribute, or null.
//        Object constantValue = null;
//        // - The string corresponding to the Signature attribute, or null.
//        String signature = null;
//        // - The offset of the RuntimeVisibleAnnotations attribute, or 0.
//        int runtimeVisibleAnnotationsOffset = 0;
//        // - The offset of the RuntimeInvisibleAnnotations attribute, or 0.
//        int runtimeInvisibleAnnotationsOffset = 0;
//        // - The offset of the RuntimeVisibleTypeAnnotations attribute, or 0.
//        int runtimeVisibleTypeAnnotationsOffset = 0;
//        // - The offset of the RuntimeInvisibleTypeAnnotations attribute, or 0.
//        int runtimeInvisibleTypeAnnotationsOffset = 0;
//        // - The non standard attributes (linked with their {@link Attribute#nextAttribute} field).
//        //   This list in the <i>reverse order</i> or their order in the ClassFile structure.
//        Attribute attributes = null;
//
//        int attributesCount = readUnsignedShort(currentOffset);
//        currentOffset += 2;
//        while (attributesCount-- > 0) {
//            // Read the attribute_info's attribute_name and attribute_length fields.
//            String attributeName = readUTF8(currentOffset, charBuffer);
//            int attributeLength = readInt(currentOffset + 2);
//            currentOffset += 6;
//            // The tests are sorted in decreasing frequency order (based on frequencies observed on
//            // typical classes).
//            if (Constants.CONSTANT_VALUE.equals(attributeName)) {
//                int constantvalueIndex = readUnsignedShort(currentOffset);
//                constantValue = constantvalueIndex == 0 ? null : readConst(constantvalueIndex, charBuffer);
//            } else if (Constants.SIGNATURE.equals(attributeName)) {
//                signature = readUTF8(currentOffset, charBuffer);
//            } else if (Constants.DEPRECATED.equals(attributeName)) {
//                accessFlags |= Opcodes.ACC_DEPRECATED;
//            } else if (Constants.SYNTHETIC.equals(attributeName)) {
//                accessFlags |= Opcodes.ACC_SYNTHETIC;
//            } else if (Constants.RUNTIME_VISIBLE_ANNOTATIONS.equals(attributeName)) {
//                runtimeVisibleAnnotationsOffset = currentOffset;
//            } else if (Constants.RUNTIME_VISIBLE_TYPE_ANNOTATIONS.equals(attributeName)) {
//                runtimeVisibleTypeAnnotationsOffset = currentOffset;
//            } else if (Constants.RUNTIME_INVISIBLE_ANNOTATIONS.equals(attributeName)) {
//                runtimeInvisibleAnnotationsOffset = currentOffset;
//            } else if (Constants.RUNTIME_INVISIBLE_TYPE_ANNOTATIONS.equals(attributeName)) {
//                runtimeInvisibleTypeAnnotationsOffset = currentOffset;
//            } else {
//                Attribute attribute =
//                        readAttribute(
//                                context.attributePrototypes,
//                                attributeName,
//                                currentOffset,
//                                attributeLength,
//                                charBuffer,
//                                -1,
//                                null);
//                attribute.nextAttribute = attributes;
//                attributes = attribute;
//            }
//            currentOffset += attributeLength;
//        }
//
//        // Visit the field declaration.
//        FieldVisitor fieldVisitor =
//                classVisitor.visitField(accessFlags, name, descriptor, signature, constantValue);
//        if (fieldVisitor == null) {
//            return currentOffset;
//        }
//
//        // Visit the RuntimeVisibleAnnotations attribute.
//        if (runtimeVisibleAnnotationsOffset != 0) {
//            int numAnnotations = readUnsignedShort(runtimeVisibleAnnotationsOffset);
//            int currentAnnotationOffset = runtimeVisibleAnnotationsOffset + 2;
//            while (numAnnotations-- > 0) {
//                // Parse the type_index field.
//                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
//                currentAnnotationOffset += 2;
//                // Parse num_element_value_pairs and element_value_pairs and visit these values.
//                currentAnnotationOffset =
//                        readElementValues(
//                                fieldVisitor.visitAnnotation(annotationDescriptor, /* visible = */ true),
//                                currentAnnotationOffset,
//                                /* named = */ true,
//                                charBuffer);
//            }
//        }
//
//        // Visit the RuntimeInvisibleAnnotations attribute.
//        if (runtimeInvisibleAnnotationsOffset != 0) {
//            int numAnnotations = readUnsignedShort(runtimeInvisibleAnnotationsOffset);
//            int currentAnnotationOffset = runtimeInvisibleAnnotationsOffset + 2;
//            while (numAnnotations-- > 0) {
//                // Parse the type_index field.
//                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
//                currentAnnotationOffset += 2;
//                // Parse num_element_value_pairs and element_value_pairs and visit these values.
//                currentAnnotationOffset =
//                        readElementValues(
//                                fieldVisitor.visitAnnotation(annotationDescriptor, /* visible = */ false),
//                                currentAnnotationOffset,
//                                /* named = */ true,
//                                charBuffer);
//            }
//        }
//
//        // Visit the RuntimeVisibleTypeAnnotations attribute.
//        if (runtimeVisibleTypeAnnotationsOffset != 0) {
//            int numAnnotations = readUnsignedShort(runtimeVisibleTypeAnnotationsOffset);
//            int currentAnnotationOffset = runtimeVisibleTypeAnnotationsOffset + 2;
//            while (numAnnotations-- > 0) {
//                // Parse the target_type, target_info and target_path fields.
//                currentAnnotationOffset = readTypeAnnotationTarget(context, currentAnnotationOffset);
//                // Parse the type_index field.
//                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
//                currentAnnotationOffset += 2;
//                // Parse num_element_value_pairs and element_value_pairs and visit these values.
//                currentAnnotationOffset =
//                        readElementValues(
//                                fieldVisitor.visitTypeAnnotation(
//                                        context.currentTypeAnnotationTarget,
//                                        context.currentTypeAnnotationTargetPath,
//                                        annotationDescriptor,
//                                        /* visible = */ true),
//                                currentAnnotationOffset,
//                                /* named = */ true,
//                                charBuffer);
//            }
//        }
//
//        // Visit the RuntimeInvisibleTypeAnnotations attribute.
//        if (runtimeInvisibleTypeAnnotationsOffset != 0) {
//            int numAnnotations = readUnsignedShort(runtimeInvisibleTypeAnnotationsOffset);
//            int currentAnnotationOffset = runtimeInvisibleTypeAnnotationsOffset + 2;
//            while (numAnnotations-- > 0) {
//                // Parse the target_type, target_info and target_path fields.
//                currentAnnotationOffset = readTypeAnnotationTarget(context, currentAnnotationOffset);
//                // Parse the type_index field.
//                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
//                currentAnnotationOffset += 2;
//                // Parse num_element_value_pairs and element_value_pairs and visit these values.
//                currentAnnotationOffset =
//                        readElementValues(
//                                fieldVisitor.visitTypeAnnotation(
//                                        context.currentTypeAnnotationTarget,
//                                        context.currentTypeAnnotationTargetPath,
//                                        annotationDescriptor,
//                                        /* visible = */ false),
//                                currentAnnotationOffset,
//                                /* named = */ true,
//                                charBuffer);
//            }
//        }
//
//        // Visit the non standard attributes.
//        while (attributes != null) {
//            // Copy and reset the nextAttribute field so that it can also be used in FieldWriter.
//            Attribute nextAttribute = attributes.nextAttribute;
//            attributes.nextAttribute = null;
//            fieldVisitor.visitAttribute(attributes);
//            attributes = nextAttribute;
//        }
//
//        // Visit the end of the field.
//        fieldVisitor.visitEnd();
//        return currentOffset;
//    }
//
//    /**
//     * Reads a JVMS method_info structure and makes the given visitor visit it.
//     *
//     * @param classVisitor the visitor that must visit the method.
//     * @param context information about the class being parsed.
//     * @param methodInfoOffset the start offset of the method_info structure.
//     * @return the offset of the first byte following the method_info structure.
//     */
//    private int readMethod(
//            final ClassVisitor classVisitor, final Context context, final int methodInfoOffset) {
//        char[] charBuffer = context.charBuffer;
//
//        // Read the access_flags, name_index and descriptor_index fields.
//        int currentOffset = methodInfoOffset;
//        context.currentMethodAccessFlags = readUnsignedShort(currentOffset);
//        context.currentMethodName = readUTF8(currentOffset + 2, charBuffer);
//        context.currentMethodDescriptor = readUTF8(currentOffset + 4, charBuffer);
//        currentOffset += 6;
//
//        // Read the method attributes (the variables are ordered as in Section 4.7 of the JVMS).
//        // Attribute offsets exclude the attribute_name_index and attribute_length fields.
//        // - The offset of the Code attribute, or 0.
//        int codeOffset = 0;
//        // - The offset of the Exceptions attribute, or 0.
//        int exceptionsOffset = 0;
//        // - The strings corresponding to the Exceptions attribute, or null.
//        String[] exceptions = null;
//        // - Whether the method has a Synthetic attribute.
//        boolean synthetic = false;
//        // - The constant pool index contained in the Signature attribute, or 0.
//        int signatureIndex = 0;
//        // - The offset of the RuntimeVisibleAnnotations attribute, or 0.
//        int runtimeVisibleAnnotationsOffset = 0;
//        // - The offset of the RuntimeInvisibleAnnotations attribute, or 0.
//        int runtimeInvisibleAnnotationsOffset = 0;
//        // - The offset of the RuntimeVisibleParameterAnnotations attribute, or 0.
//        int runtimeVisibleParameterAnnotationsOffset = 0;
//        // - The offset of the RuntimeInvisibleParameterAnnotations attribute, or 0.
//        int runtimeInvisibleParameterAnnotationsOffset = 0;
//        // - The offset of the RuntimeVisibleTypeAnnotations attribute, or 0.
//        int runtimeVisibleTypeAnnotationsOffset = 0;
//        // - The offset of the RuntimeInvisibleTypeAnnotations attribute, or 0.
//        int runtimeInvisibleTypeAnnotationsOffset = 0;
//        // - The offset of the AnnotationDefault attribute, or 0.
//        int annotationDefaultOffset = 0;
//        // - The offset of the MethodParameters attribute, or 0.
//        int methodParametersOffset = 0;
//        // - The non standard attributes (linked with their {@link Attribute#nextAttribute} field).
//        //   This list in the <i>reverse order</i> or their order in the ClassFile structure.
//        Attribute attributes = null;
//
//        int attributesCount = readUnsignedShort(currentOffset);
//        currentOffset += 2;
//        while (attributesCount-- > 0) {
//            // Read the attribute_info's attribute_name and attribute_length fields.
//            String attributeName = readUTF8(currentOffset, charBuffer);
//            int attributeLength = readInt(currentOffset + 2);
//            currentOffset += 6;
//            // The tests are sorted in decreasing frequency order (based on frequencies observed on
//            // typical classes).
//            if (Constants.CODE.equals(attributeName)) {
//                if ((context.parsingOptions & SKIP_CODE) == 0) {
//                    codeOffset = currentOffset;
//                }
//            } else if (Constants.EXCEPTIONS.equals(attributeName)) {
//                exceptionsOffset = currentOffset;
//                exceptions = new String[readUnsignedShort(exceptionsOffset)];
//                int currentExceptionOffset = exceptionsOffset + 2;
//                for (int i = 0; i < exceptions.length; ++i) {
//                    exceptions[i] = readClass(currentExceptionOffset, charBuffer);
//                    currentExceptionOffset += 2;
//                }
//            } else if (Constants.SIGNATURE.equals(attributeName)) {
//                signatureIndex = readUnsignedShort(currentOffset);
//            } else if (Constants.DEPRECATED.equals(attributeName)) {
//                context.currentMethodAccessFlags |= Opcodes.ACC_DEPRECATED;
//            } else if (Constants.RUNTIME_VISIBLE_ANNOTATIONS.equals(attributeName)) {
//                runtimeVisibleAnnotationsOffset = currentOffset;
//            } else if (Constants.RUNTIME_VISIBLE_TYPE_ANNOTATIONS.equals(attributeName)) {
//                runtimeVisibleTypeAnnotationsOffset = currentOffset;
//            } else if (Constants.ANNOTATION_DEFAULT.equals(attributeName)) {
//                annotationDefaultOffset = currentOffset;
//            } else if (Constants.SYNTHETIC.equals(attributeName)) {
//                synthetic = true;
//                context.currentMethodAccessFlags |= Opcodes.ACC_SYNTHETIC;
//            } else if (Constants.RUNTIME_INVISIBLE_ANNOTATIONS.equals(attributeName)) {
//                runtimeInvisibleAnnotationsOffset = currentOffset;
//            } else if (Constants.RUNTIME_INVISIBLE_TYPE_ANNOTATIONS.equals(attributeName)) {
//                runtimeInvisibleTypeAnnotationsOffset = currentOffset;
//            } else if (Constants.RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS.equals(attributeName)) {
//                runtimeVisibleParameterAnnotationsOffset = currentOffset;
//            } else if (Constants.RUNTIME_INVISIBLE_PARAMETER_ANNOTATIONS.equals(attributeName)) {
//                runtimeInvisibleParameterAnnotationsOffset = currentOffset;
//            } else if (Constants.METHOD_PARAMETERS.equals(attributeName)) {
//                methodParametersOffset = currentOffset;
//            } else {
//                Attribute attribute =
//                        readAttribute(
//                                context.attributePrototypes,
//                                attributeName,
//                                currentOffset,
//                                attributeLength,
//                                charBuffer,
//                                -1,
//                                null);
//                attribute.nextAttribute = attributes;
//                attributes = attribute;
//            }
//            currentOffset += attributeLength;
//        }
//
//        // Visit the method declaration.
//        MethodVisitor methodVisitor =
//                classVisitor.visitMethod(
//                        context.currentMethodAccessFlags,
//                        context.currentMethodName,
//                        context.currentMethodDescriptor,
//                        signatureIndex == 0 ? null : readUtf(signatureIndex, charBuffer),
//                        exceptions);
//        if (methodVisitor == null) {
//            return currentOffset;
//        }
//
//        // If the returned MethodVisitor is in fact a MethodWriter, it means there is no method
//        // adapter between the reader and the writer. In this case, it might be possible to copy
//        // the method attributes directly into the writer. If so, return early without visiting
//        // the content of these attributes.
//        if (methodVisitor instanceof MethodWriter) {
//            MethodWriter methodWriter = (MethodWriter) methodVisitor;
//            if (methodWriter.canCopyMethodAttributes(
//                    this,
//                    synthetic,
//                    (context.currentMethodAccessFlags & Opcodes.ACC_DEPRECATED) != 0,
//                    readUnsignedShort(methodInfoOffset + 4),
//                    signatureIndex,
//                    exceptionsOffset)) {
//                methodWriter.setMethodAttributesSource(methodInfoOffset, currentOffset - methodInfoOffset);
//                return currentOffset;
//            }
//        }
//
//        // Visit the MethodParameters attribute.
//        if (methodParametersOffset != 0 && (context.parsingOptions & SKIP_DEBUG) == 0) {
//            int parametersCount = readByte(methodParametersOffset);
//            int currentParameterOffset = methodParametersOffset + 1;
//            while (parametersCount-- > 0) {
//                // Read the name_index and access_flags fields and visit them.
//                methodVisitor.visitParameter(
//                        readUTF8(currentParameterOffset, charBuffer),
//                        readUnsignedShort(currentParameterOffset + 2));
//                currentParameterOffset += 4;
//            }
//        }
//
//        // Visit the AnnotationDefault attribute.
//        if (annotationDefaultOffset != 0) {
//            AnnotationVisitor annotationVisitor = methodVisitor.visitAnnotationDefault();
//            readElementValue(annotationVisitor, annotationDefaultOffset, null, charBuffer);
//            if (annotationVisitor != null) {
//                annotationVisitor.visitEnd();
//            }
//        }
//
//        // Visit the RuntimeVisibleAnnotations attribute.
//        if (runtimeVisibleAnnotationsOffset != 0) {
//            int numAnnotations = readUnsignedShort(runtimeVisibleAnnotationsOffset);
//            int currentAnnotationOffset = runtimeVisibleAnnotationsOffset + 2;
//            while (numAnnotations-- > 0) {
//                // Parse the type_index field.
//                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
//                currentAnnotationOffset += 2;
//                // Parse num_element_value_pairs and element_value_pairs and visit these values.
//                currentAnnotationOffset =
//                        readElementValues(
//                                methodVisitor.visitAnnotation(annotationDescriptor, /* visible = */ true),
//                                currentAnnotationOffset,
//                                /* named = */ true,
//                                charBuffer);
//            }
//        }
//
//        // Visit the RuntimeInvisibleAnnotations attribute.
//        if (runtimeInvisibleAnnotationsOffset != 0) {
//            int numAnnotations = readUnsignedShort(runtimeInvisibleAnnotationsOffset);
//            int currentAnnotationOffset = runtimeInvisibleAnnotationsOffset + 2;
//            while (numAnnotations-- > 0) {
//                // Parse the type_index field.
//                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
//                currentAnnotationOffset += 2;
//                // Parse num_element_value_pairs and element_value_pairs and visit these values.
//                currentAnnotationOffset =
//                        readElementValues(
//                                methodVisitor.visitAnnotation(annotationDescriptor, /* visible = */ false),
//                                currentAnnotationOffset,
//                                /* named = */ true,
//                                charBuffer);
//            }
//        }
//
//        // Visit the RuntimeVisibleTypeAnnotations attribute.
//        if (runtimeVisibleTypeAnnotationsOffset != 0) {
//            int numAnnotations = readUnsignedShort(runtimeVisibleTypeAnnotationsOffset);
//            int currentAnnotationOffset = runtimeVisibleTypeAnnotationsOffset + 2;
//            while (numAnnotations-- > 0) {
//                // Parse the target_type, target_info and target_path fields.
//                currentAnnotationOffset = readTypeAnnotationTarget(context, currentAnnotationOffset);
//                // Parse the type_index field.
//                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
//                currentAnnotationOffset += 2;
//                // Parse num_element_value_pairs and element_value_pairs and visit these values.
//                currentAnnotationOffset =
//                        readElementValues(
//                                methodVisitor.visitTypeAnnotation(
//                                        context.currentTypeAnnotationTarget,
//                                        context.currentTypeAnnotationTargetPath,
//                                        annotationDescriptor,
//                                        /* visible = */ true),
//                                currentAnnotationOffset,
//                                /* named = */ true,
//                                charBuffer);
//            }
//        }
//
//        // Visit the RuntimeInvisibleTypeAnnotations attribute.
//        if (runtimeInvisibleTypeAnnotationsOffset != 0) {
//            int numAnnotations = readUnsignedShort(runtimeInvisibleTypeAnnotationsOffset);
//            int currentAnnotationOffset = runtimeInvisibleTypeAnnotationsOffset + 2;
//            while (numAnnotations-- > 0) {
//                // Parse the target_type, target_info and target_path fields.
//                currentAnnotationOffset = readTypeAnnotationTarget(context, currentAnnotationOffset);
//                // Parse the type_index field.
//                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
//                currentAnnotationOffset += 2;
//                // Parse num_element_value_pairs and element_value_pairs and visit these values.
//                currentAnnotationOffset =
//                        readElementValues(
//                                methodVisitor.visitTypeAnnotation(
//                                        context.currentTypeAnnotationTarget,
//                                        context.currentTypeAnnotationTargetPath,
//                                        annotationDescriptor,
//                                        /* visible = */ false),
//                                currentAnnotationOffset,
//                                /* named = */ true,
//                                charBuffer);
//            }
//        }
//
//        // Visit the RuntimeVisibleParameterAnnotations attribute.
//        if (runtimeVisibleParameterAnnotationsOffset != 0) {
//            readParameterAnnotations(
//                    methodVisitor, context, runtimeVisibleParameterAnnotationsOffset, /* visible = */ true);
//        }
//
//        // Visit the RuntimeInvisibleParameterAnnotations attribute.
//        if (runtimeInvisibleParameterAnnotationsOffset != 0) {
//            readParameterAnnotations(
//                    methodVisitor,
//                    context,
//                    runtimeInvisibleParameterAnnotationsOffset,
//                    /* visible = */ false);
//        }
//
//        // Visit the non standard attributes.
//        while (attributes != null) {
//            // Copy and reset the nextAttribute field so that it can also be used in MethodWriter.
//            Attribute nextAttribute = attributes.nextAttribute;
//            attributes.nextAttribute = null;
//            methodVisitor.visitAttribute(attributes);
//            attributes = nextAttribute;
//        }
//
//        // Visit the Code attribute.
//        if (codeOffset != 0) {
//            methodVisitor.visitCode();
//            readCode(methodVisitor, context, codeOffset);
//        }
//
//        // Visit the end of the method.
//        methodVisitor.visitEnd();
//        return currentOffset;
//    }
//
//    // ----------------------------------------------------------------------------------------------
//    // Methods to parse a Code attribute
//    // ----------------------------------------------------------------------------------------------
//
//    /**
//     * Reads a JVMS 'Code' attribute and makes the given visitor visit it.
//     *
//     * @param methodVisitor the visitor that must visit the Code attribute.
//     * @param context information about the class being parsed.
//     * @param codeOffset the start offset in {@link #classFileBuffer} of the Code attribute, excluding
//     *     its attribute_name_index and attribute_length fields.
//     */
//    private void readCode(
//            final MethodVisitor methodVisitor, final Context context, final int codeOffset) {
//        int currentOffset = codeOffset;
//
//        // Read the max_stack, max_locals and code_length fields.
//        final byte[] classBuffer = classFileBuffer;
//        final char[] charBuffer = context.charBuffer;
//        final int maxStack = readUnsignedShort(currentOffset);
//        final int maxLocals = readUnsignedShort(currentOffset + 2);
//        final int codeLength = readInt(currentOffset + 4);
//        currentOffset += 8;
//
//        // Read the bytecode 'code' array to create a label for each referenced instruction.
//        final int bytecodeStartOffset = currentOffset;
//        final int bytecodeEndOffset = currentOffset + codeLength;
//        final Label[] labels = context.currentMethodLabels = new Label[codeLength + 1];
//        while (currentOffset < bytecodeEndOffset) {
//            final int bytecodeOffset = currentOffset - bytecodeStartOffset;
//            final int opcode = classBuffer[currentOffset] & 0xFF;
//            switch (opcode) {
//                case Constants.NOP:
//                case Constants.ACONST_NULL:
//                case Constants.ICONST_M1:
//                case Constants.ICONST_0:
//                case Constants.ICONST_1:
//                case Constants.ICONST_2:
//                case Constants.ICONST_3:
//                case Constants.ICONST_4:
//                case Constants.ICONST_5:
//                case Constants.LCONST_0:
//                case Constants.LCONST_1:
//                case Constants.FCONST_0:
//                case Constants.FCONST_1:
//                case Constants.FCONST_2:
//                case Constants.DCONST_0:
//                case Constants.DCONST_1:
//                case Constants.IALOAD:
//                case Constants.LALOAD:
//                case Constants.FALOAD:
//                case Constants.DALOAD:
//                case Constants.AALOAD:
//                case Constants.BALOAD:
//                case Constants.CALOAD:
//                case Constants.SALOAD:
//                case Constants.IASTORE:
//                case Constants.LASTORE:
//                case Constants.FASTORE:
//                case Constants.DASTORE:
//                case Constants.AASTORE:
//                case Constants.BASTORE:
//                case Constants.CASTORE:
//                case Constants.SASTORE:
//                case Constants.POP:
//                case Constants.POP2:
//                case Constants.DUP:
//                case Constants.DUP_X1:
//                case Constants.DUP_X2:
//                case Constants.DUP2:
//                case Constants.DUP2_X1:
//                case Constants.DUP2_X2:
//                case Constants.SWAP:
//                case Constants.IADD:
//                case Constants.LADD:
//                case Constants.FADD:
//                case Constants.DADD:
//                case Constants.ISUB:
//                case Constants.LSUB:
//                case Constants.FSUB:
//                case Constants.DSUB:
//                case Constants.IMUL:
//                case Constants.LMUL:
//                case Constants.FMUL:
//                case Constants.DMUL:
//                case Constants.IDIV:
//                case Constants.LDIV:
//                case Constants.FDIV:
//                case Constants.DDIV:
//                case Constants.IREM:
//                case Constants.LREM:
//                case Constants.FREM:
//                case Constants.DREM:
//                case Constants.INEG:
//                case Constants.LNEG:
//                case Constants.FNEG:
//                case Constants.DNEG:
//                case Constants.ISHL:
//                case Constants.LSHL:
//                case Constants.ISHR:
//                case Constants.LSHR:
//                case Constants.IUSHR:
//                case Constants.LUSHR:
//                case Constants.IAND:
//                case Constants.LAND:
//                case Constants.IOR:
//                case Constants.LOR:
//                case Constants.IXOR:
//                case Constants.LXOR:
//                case Constants.I2L:
//                case Constants.I2F:
//                case Constants.I2D:
//                case Constants.L2I:
//                case Constants.L2F:
//                case Constants.L2D:
//                case Constants.F2I:
//                case Constants.F2L:
//                case Constants.F2D:
//                case Constants.D2I:
//                case Constants.D2L:
//                case Constants.D2F:
//                case Constants.I2B:
//                case Constants.I2C:
//                case Constants.I2S:
//                case Constants.LCMP:
//                case Constants.FCMPL:
//                case Constants.FCMPG:
//                case Constants.DCMPL:
//                case Constants.DCMPG:
//                case Constants.IRETURN:
//                case Constants.LRETURN:
//                case Constants.FRETURN:
//                case Constants.DRETURN:
//                case Constants.ARETURN:
//                case Constants.RETURN:
//                case Constants.ARRAYLENGTH:
//                case Constants.ATHROW:
//                case Constants.MONITORENTER:
//                case Constants.MONITOREXIT:
//                case Constants.ILOAD_0:
//                case Constants.ILOAD_1:
//                case Constants.ILOAD_2:
//                case Constants.ILOAD_3:
//                case Constants.LLOAD_0:
//                case Constants.LLOAD_1:
//                case Constants.LLOAD_2:
//                case Constants.LLOAD_3:
//                case Constants.FLOAD_0:
//                case Constants.FLOAD_1:
//                case Constants.FLOAD_2:
//                case Constants.FLOAD_3:
//                case Constants.DLOAD_0:
//                case Constants.DLOAD_1:
//                case Constants.DLOAD_2:
//                case Constants.DLOAD_3:
//                case Constants.ALOAD_0:
//                case Constants.ALOAD_1:
//                case Constants.ALOAD_2:
//                case Constants.ALOAD_3:
//                case Constants.ISTORE_0:
//                case Constants.ISTORE_1:
//                case Constants.ISTORE_2:
//                case Constants.ISTORE_3:
//                case Constants.LSTORE_0:
//                case Constants.LSTORE_1:
//                case Constants.LSTORE_2:
//                case Constants.LSTORE_3:
//                case Constants.FSTORE_0:
//                case Constants.FSTORE_1:
//                case Constants.FSTORE_2:
//                case Constants.FSTORE_3:
//                case Constants.DSTORE_0:
//                case Constants.DSTORE_1:
//                case Constants.DSTORE_2:
//                case Constants.DSTORE_3:
//                case Constants.ASTORE_0:
//                case Constants.ASTORE_1:
//                case Constants.ASTORE_2:
//                case Constants.ASTORE_3:
//                    currentOffset += 1;
//                    break;
//                case Constants.IFEQ:
//                case Constants.IFNE:
//                case Constants.IFLT:
//                case Constants.IFGE:
//                case Constants.IFGT:
//                case Constants.IFLE:
//                case Constants.IF_ICMPEQ:
//                case Constants.IF_ICMPNE:
//                case Constants.IF_ICMPLT:
//                case Constants.IF_ICMPGE:
//                case Constants.IF_ICMPGT:
//                case Constants.IF_ICMPLE:
//                case Constants.IF_ACMPEQ:
//                case Constants.IF_ACMPNE:
//                case Constants.GOTO:
//                case Constants.JSR:
//                case Constants.IFNULL:
//                case Constants.IFNONNULL:
//                    createLabel(bytecodeOffset + readShort(currentOffset + 1), labels);
//                    currentOffset += 3;
//                    break;
//                case Constants.ASM_IFEQ:
//                case Constants.ASM_IFNE:
//                case Constants.ASM_IFLT:
//                case Constants.ASM_IFGE:
//                case Constants.ASM_IFGT:
//                case Constants.ASM_IFLE:
//                case Constants.ASM_IF_ICMPEQ:
//                case Constants.ASM_IF_ICMPNE:
//                case Constants.ASM_IF_ICMPLT:
//                case Constants.ASM_IF_ICMPGE:
//                case Constants.ASM_IF_ICMPGT:
//                case Constants.ASM_IF_ICMPLE:
//                case Constants.ASM_IF_ACMPEQ:
//                case Constants.ASM_IF_ACMPNE:
//                case Constants.ASM_GOTO:
//                case Constants.ASM_JSR:
//                case Constants.ASM_IFNULL:
//                case Constants.ASM_IFNONNULL:
//                    createLabel(bytecodeOffset + readUnsignedShort(currentOffset + 1), labels);
//                    currentOffset += 3;
//                    break;
//                case Constants.GOTO_W:
//                case Constants.JSR_W:
//                case Constants.ASM_GOTO_W:
//                    createLabel(bytecodeOffset + readInt(currentOffset + 1), labels);
//                    currentOffset += 5;
//                    break;
//                case Constants.WIDE:
//                    switch (classBuffer[currentOffset + 1] & 0xFF) {
//                        case Constants.ILOAD:
//                        case Constants.FLOAD:
//                        case Constants.ALOAD:
//                        case Constants.LLOAD:
//                        case Constants.DLOAD:
//                        case Constants.ISTORE:
//                        case Constants.FSTORE:
//                        case Constants.ASTORE:
//                        case Constants.LSTORE:
//                        case Constants.DSTORE:
//                        case Constants.RET:
//                            currentOffset += 4;
//                            break;
//                        case Constants.IINC:
//                            currentOffset += 6;
//                            break;
//                        default:
//                            throw new IllegalArgumentException();
//                    }
//                    break;
//                case Constants.TABLESWITCH:
//                    // Skip 0 to 3 padding bytes.
//                    currentOffset += 4 - (bytecodeOffset & 3);
//                    // Read the default label and the number of table entries.
//                    createLabel(bytecodeOffset + readInt(currentOffset), labels);
//                    int numTableEntries = readInt(currentOffset + 8) - readInt(currentOffset + 4) + 1;
//                    currentOffset += 12;
//                    // Read the table labels.
//                    while (numTableEntries-- > 0) {
//                        createLabel(bytecodeOffset + readInt(currentOffset), labels);
//                        currentOffset += 4;
//                    }
//                    break;
//                case Constants.LOOKUPSWITCH:
//                    // Skip 0 to 3 padding bytes.
//                    currentOffset += 4 - (bytecodeOffset & 3);
//                    // Read the default label and the number of switch cases.
//                    createLabel(bytecodeOffset + readInt(currentOffset), labels);
//                    int numSwitchCases = readInt(currentOffset + 4);
//                    currentOffset += 8;
//                    // Read the switch labels.
//                    while (numSwitchCases-- > 0) {
//                        createLabel(bytecodeOffset + readInt(currentOffset + 4), labels);
//                        currentOffset += 8;
//                    }
//                    break;
//                case Constants.ILOAD:
//                case Constants.LLOAD:
//                case Constants.FLOAD:
//                case Constants.DLOAD:
//                case Constants.ALOAD:
//                case Constants.ISTORE:
//                case Constants.LSTORE:
//                case Constants.FSTORE:
//                case Constants.DSTORE:
//                case Constants.ASTORE:
//                case Constants.RET:
//                case Constants.BIPUSH:
//                case Constants.NEWARRAY:
//                case Constants.LDC:
//                    currentOffset += 2;
//                    break;
//                case Constants.SIPUSH:
//                case Constants.LDC_W:
//                case Constants.LDC2_W:
//                case Constants.GETSTATIC:
//                case Constants.PUTSTATIC:
//                case Constants.GETFIELD:
//                case Constants.PUTFIELD:
//                case Constants.INVOKEVIRTUAL:
//                case Constants.INVOKESPECIAL:
//                case Constants.INVOKESTATIC:
//                case Constants.NEW:
//                case Constants.ANEWARRAY:
//                case Constants.CHECKCAST:
//                case Constants.INSTANCEOF:
//                case Constants.IINC:
//                    currentOffset += 3;
//                    break;
//                case Constants.INVOKEINTERFACE:
//                case Constants.INVOKEDYNAMIC:
//                    currentOffset += 5;
//                    break;
//                case Constants.MULTIANEWARRAY:
//                    currentOffset += 4;
//                    break;
//                default:
//                    throw new IllegalArgumentException();
//            }
//        }
//
//        // Read the 'exception_table_length' and 'exception_table' field to create a label for each
//        // referenced instruction, and to make methodVisitor visit the corresponding try catch blocks.
//        int exceptionTableLength = readUnsignedShort(currentOffset);
//        currentOffset += 2;
//        while (exceptionTableLength-- > 0) {
//            Label start = createLabel(readUnsignedShort(currentOffset), labels);
//            Label end = createLabel(readUnsignedShort(currentOffset + 2), labels);
//            Label handler = createLabel(readUnsignedShort(currentOffset + 4), labels);
//            String catchType = readUTF8(cpInfoOffsets[readUnsignedShort(currentOffset + 6)], charBuffer);
//            currentOffset += 8;
//            methodVisitor.visitTryCatchBlock(start, end, handler, catchType);
//        }
//
//        // Read the Code attributes to create a label for each referenced instruction (the variables
//        // are ordered as in Section 4.7 of the JVMS). Attribute offsets exclude the
//        // attribute_name_index and attribute_length fields.
//        // - The offset of the current 'stack_map_frame' in the StackMap[Table] attribute, or 0.
//        // Initially, this is the offset of the first 'stack_map_frame' entry. Then this offset is
//        // updated after each stack_map_frame is read.
//        int stackMapFrameOffset = 0;
//        // - The end offset of the StackMap[Table] attribute, or 0.
//        int stackMapTableEndOffset = 0;
//        // - Whether the stack map frames are compressed (i.e. in a StackMapTable) or not.
//        boolean compressedFrames = true;
//        // - The offset of the LocalVariableTable attribute, or 0.
//        int localVariableTableOffset = 0;
//        // - The offset of the LocalVariableTypeTable attribute, or 0.
//        int localVariableTypeTableOffset = 0;
//        // - The offset of each 'type_annotation' entry in the RuntimeVisibleTypeAnnotations
//        // attribute, or null.
//        int[] visibleTypeAnnotationOffsets = null;
//        // - The offset of each 'type_annotation' entry in the RuntimeInvisibleTypeAnnotations
//        // attribute, or null.
//        int[] invisibleTypeAnnotationOffsets = null;
//        // - The non standard attributes (linked with their {@link Attribute#nextAttribute} field).
//        //   This list in the <i>reverse order</i> or their order in the ClassFile structure.
//        Attribute attributes = null;
//
//        int attributesCount = readUnsignedShort(currentOffset);
//        currentOffset += 2;
//        while (attributesCount-- > 0) {
//            // Read the attribute_info's attribute_name and attribute_length fields.
//            String attributeName = readUTF8(currentOffset, charBuffer);
//            int attributeLength = readInt(currentOffset + 2);
//            currentOffset += 6;
//            if (Constants.LOCAL_VARIABLE_TABLE.equals(attributeName)) {
//                if ((context.parsingOptions & SKIP_DEBUG) == 0) {
//                    localVariableTableOffset = currentOffset;
//                    // Parse the attribute to find the corresponding (debug only) labels.
//                    int currentLocalVariableTableOffset = currentOffset;
//                    int localVariableTableLength = readUnsignedShort(currentLocalVariableTableOffset);
//                    currentLocalVariableTableOffset += 2;
//                    while (localVariableTableLength-- > 0) {
//                        int startPc = readUnsignedShort(currentLocalVariableTableOffset);
//                        createDebugLabel(startPc, labels);
//                        int length = readUnsignedShort(currentLocalVariableTableOffset + 2);
//                        createDebugLabel(startPc + length, labels);
//                        // Skip the name_index, descriptor_index and index fields (2 bytes each).
//                        currentLocalVariableTableOffset += 10;
//                    }
//                }
//            } else if (Constants.LOCAL_VARIABLE_TYPE_TABLE.equals(attributeName)) {
//                localVariableTypeTableOffset = currentOffset;
//                // Here we do not extract the labels corresponding to the attribute content. We assume they
//                // are the same or a subset of those of the LocalVariableTable attribute.
//            } else if (Constants.LINE_NUMBER_TABLE.equals(attributeName)) {
//                if ((context.parsingOptions & SKIP_DEBUG) == 0) {
//                    // Parse the attribute to find the corresponding (debug only) labels.
//                    int currentLineNumberTableOffset = currentOffset;
//                    int lineNumberTableLength = readUnsignedShort(currentLineNumberTableOffset);
//                    currentLineNumberTableOffset += 2;
//                    while (lineNumberTableLength-- > 0) {
//                        int startPc = readUnsignedShort(currentLineNumberTableOffset);
//                        int lineNumber = readUnsignedShort(currentLineNumberTableOffset + 2);
//                        currentLineNumberTableOffset += 4;
//                        createDebugLabel(startPc, labels);
//                        labels[startPc].addLineNumber(lineNumber);
//                    }
//                }
//            } else if (Constants.RUNTIME_VISIBLE_TYPE_ANNOTATIONS.equals(attributeName)) {
//                visibleTypeAnnotationOffsets =
//                        readTypeAnnotations(methodVisitor, context, currentOffset, /* visible = */ true);
//                // Here we do not extract the labels corresponding to the attribute content. This would
//                // require a full parsing of the attribute, which would need to be repeated when parsing
//                // the bytecode instructions (see below). Instead, the content of the attribute is read one
//                // type annotation at a time (i.e. after a type annotation has been visited, the next type
//                // annotation is read), and the labels it contains are also extracted one annotation at a
//                // time. This assumes that type annotations are ordered by increasing bytecode offset.
//            } else if (Constants.RUNTIME_INVISIBLE_TYPE_ANNOTATIONS.equals(attributeName)) {
//                invisibleTypeAnnotationOffsets =
//                        readTypeAnnotations(methodVisitor, context, currentOffset, /* visible = */ false);
//                // Same comment as above for the RuntimeVisibleTypeAnnotations attribute.
//            } else if (Constants.STACK_MAP_TABLE.equals(attributeName)) {
//                if ((context.parsingOptions & SKIP_FRAMES) == 0) {
//                    stackMapFrameOffset = currentOffset + 2;
//                    stackMapTableEndOffset = currentOffset + attributeLength;
//                }
//                // Here we do not extract the labels corresponding to the attribute content. This would
//                // require a full parsing of the attribute, which would need to be repeated when parsing
//                // the bytecode instructions (see below). Instead, the content of the attribute is read one
//                // frame at a time (i.e. after a frame has been visited, the next frame is read), and the
//                // labels it contains are also extracted one frame at a time. Thanks to the ordering of
//                // frames, having only a "one frame lookahead" is not a problem, i.e. it is not possible to
//                // see an offset smaller than the offset of the current instruction and for which no Label
//                // exist. Except for UNINITIALIZED type offsets. We solve this by parsing the stack map
//                // table without a full decoding (see below).
//            } else if ("StackMap".equals(attributeName)) {
//                if ((context.parsingOptions & SKIP_FRAMES) == 0) {
//                    stackMapFrameOffset = currentOffset + 2;
//                    stackMapTableEndOffset = currentOffset + attributeLength;
//                    compressedFrames = false;
//                }
//                // IMPORTANT! Here we assume that the frames are ordered, as in the StackMapTable attribute,
//                // although this is not guaranteed by the attribute format. This allows an incremental
//                // extraction of the labels corresponding to this attribute (see the comment above for the
//                // StackMapTable attribute).
//            } else {
//                Attribute attribute =
//                        readAttribute(
//                                context.attributePrototypes,
//                                attributeName,
//                                currentOffset,
//                                attributeLength,
//                                charBuffer,
//                                codeOffset,
//                                labels);
//                attribute.nextAttribute = attributes;
//                attributes = attribute;
//            }
//            currentOffset += attributeLength;
//        }
//
//        // Initialize the context fields related to stack map frames, and generate the first
//        // (implicit) stack map frame, if needed.
//        final boolean expandFrames = (context.parsingOptions & EXPAND_FRAMES) != 0;
//        if (stackMapFrameOffset != 0) {
//            // The bytecode offset of the first explicit frame is not offset_delta + 1 but only
//            // offset_delta. Setting the implicit frame offset to -1 allows us to use of the
//            // "offset_delta + 1" rule in all cases.
//            context.currentFrameOffset = -1;
//            context.currentFrameType = 0;
//            context.currentFrameLocalCount = 0;
//            context.currentFrameLocalCountDelta = 0;
//            context.currentFrameLocalTypes = new Object[maxLocals];
//            context.currentFrameStackCount = 0;
//            context.currentFrameStackTypes = new Object[maxStack];
//            if (expandFrames) {
//                computeImplicitFrame(context);
//            }
//            // Find the labels for UNINITIALIZED frame types. Instead of decoding each element of the
//            // stack map table, we look for 3 consecutive bytes that "look like" an UNINITIALIZED type
//            // (tag ITEM_Uninitialized, offset within bytecode bounds, NEW instruction at this offset).
//            // We may find false positives (i.e. not real UNINITIALIZED types), but this should be rare,
//            // and the only consequence will be the creation of an unneeded label. This is better than
//            // creating a label for each NEW instruction, and faster than fully decoding the whole stack
//            // map table.
//            for (int offset = stackMapFrameOffset; offset < stackMapTableEndOffset - 2; ++offset) {
//                if (classBuffer[offset] == Frame.ITEM_UNINITIALIZED) {
//                    int potentialBytecodeOffset = readUnsignedShort(offset + 1);
//                    if (potentialBytecodeOffset >= 0
//                            && potentialBytecodeOffset < codeLength
//                            && (classBuffer[bytecodeStartOffset + potentialBytecodeOffset] & 0xFF)
//                            == Opcodes.NEW) {
//                        createLabel(potentialBytecodeOffset, labels);
//                    }
//                }
//            }
//        }
//        if (expandFrames && (context.parsingOptions & EXPAND_ASM_INSNS) != 0) {
//            // Expanding the ASM specific instructions can introduce F_INSERT frames, even if the method
//            // does not currently have any frame. These inserted frames must be computed by simulating the
//            // effect of the bytecode instructions, one by one, starting from the implicit first frame.
//            // For this, MethodWriter needs to know maxLocals before the first instruction is visited. To
//            // ensure this, we visit the implicit first frame here (passing only maxLocals - the rest is
//            // computed in MethodWriter).
//            methodVisitor.visitFrame(Opcodes.F_NEW, maxLocals, null, 0, null);
//        }
//
//        // Visit the bytecode instructions. First, introduce state variables for the incremental parsing
//        // of the type annotations.
//
//        // Index of the next runtime visible type annotation to read (in the
//        // visibleTypeAnnotationOffsets array).
//        int currentVisibleTypeAnnotationIndex = 0;
//        // The bytecode offset of the next runtime visible type annotation to read, or -1.
//        int currentVisibleTypeAnnotationBytecodeOffset =
//                getTypeAnnotationBytecodeOffset(visibleTypeAnnotationOffsets, 0);
//        // Index of the next runtime invisible type annotation to read (in the
//        // invisibleTypeAnnotationOffsets array).
//        int currentInvisibleTypeAnnotationIndex = 0;
//        // The bytecode offset of the next runtime invisible type annotation to read, or -1.
//        int currentInvisibleTypeAnnotationBytecodeOffset =
//                getTypeAnnotationBytecodeOffset(invisibleTypeAnnotationOffsets, 0);
//
//        // Whether a F_INSERT stack map frame must be inserted before the current instruction.
//        boolean insertFrame = false;
//
//        // The delta to subtract from a goto_w or jsr_w opcode to get the corresponding goto or jsr
//        // opcode, or 0 if goto_w and jsr_w must be left unchanged (i.e. when expanding ASM specific
//        // instructions).
//        final int wideJumpOpcodeDelta =
//                (context.parsingOptions & EXPAND_ASM_INSNS) == 0 ? Constants.WIDE_JUMP_OPCODE_DELTA : 0;
//
//        currentOffset = bytecodeStartOffset;
//        while (currentOffset < bytecodeEndOffset) {
//            final int currentBytecodeOffset = currentOffset - bytecodeStartOffset;
//
//            // Visit the label and the line number(s) for this bytecode offset, if any.
//            Label currentLabel = labels[currentBytecodeOffset];
//            if (currentLabel != null) {
//                currentLabel.accept(methodVisitor, (context.parsingOptions & SKIP_DEBUG) == 0);
//            }
//
//            // Visit the stack map frame for this bytecode offset, if any.
//            while (stackMapFrameOffset != 0
//                    && (context.currentFrameOffset == currentBytecodeOffset
//                    || context.currentFrameOffset == -1)) {
//                // If there is a stack map frame for this offset, make methodVisitor visit it, and read the
//                // next stack map frame if there is one.
//                if (context.currentFrameOffset != -1) {
//                    if (!compressedFrames || expandFrames) {
//                        methodVisitor.visitFrame(
//                                Opcodes.F_NEW,
//                                context.currentFrameLocalCount,
//                                context.currentFrameLocalTypes,
//                                context.currentFrameStackCount,
//                                context.currentFrameStackTypes);
//                    } else {
//                        methodVisitor.visitFrame(
//                                context.currentFrameType,
//                                context.currentFrameLocalCountDelta,
//                                context.currentFrameLocalTypes,
//                                context.currentFrameStackCount,
//                                context.currentFrameStackTypes);
//                    }
//                    // Since there is already a stack map frame for this bytecode offset, there is no need to
//                    // insert a new one.
//                    insertFrame = false;
//                }
//                if (stackMapFrameOffset < stackMapTableEndOffset) {
//                    stackMapFrameOffset =
//                            readStackMapFrame(stackMapFrameOffset, compressedFrames, expandFrames, context);
//                } else {
//                    stackMapFrameOffset = 0;
//                }
//            }
//
//            // Insert a stack map frame for this bytecode offset, if requested by setting insertFrame to
//            // true during the previous iteration. The actual frame content is computed in MethodWriter.
//            if (insertFrame) {
//                if ((context.parsingOptions & EXPAND_FRAMES) != 0) {
//                    methodVisitor.visitFrame(Constants.F_INSERT, 0, null, 0, null);
//                }
//                insertFrame = false;
//            }
//
//            // Visit the instruction at this bytecode offset.
//            int opcode = classBuffer[currentOffset] & 0xFF;
//            switch (opcode) {
//                case Constants.NOP:
//                case Constants.ACONST_NULL:
//                case Constants.ICONST_M1:
//                case Constants.ICONST_0:
//                case Constants.ICONST_1:
//                case Constants.ICONST_2:
//                case Constants.ICONST_3:
//                case Constants.ICONST_4:
//                case Constants.ICONST_5:
//                case Constants.LCONST_0:
//                case Constants.LCONST_1:
//                case Constants.FCONST_0:
//                case Constants.FCONST_1:
//                case Constants.FCONST_2:
//                case Constants.DCONST_0:
//                case Constants.DCONST_1:
//                case Constants.IALOAD:
//                case Constants.LALOAD:
//                case Constants.FALOAD:
//                case Constants.DALOAD:
//                case Constants.AALOAD:
//                case Constants.BALOAD:
//                case Constants.CALOAD:
//                case Constants.SALOAD:
//                case Constants.IASTORE:
//                case Constants.LASTORE:
//                case Constants.FASTORE:
//                case Constants.DASTORE:
//                case Constants.AASTORE:
//                case Constants.BASTORE:
//                case Constants.CASTORE:
//                case Constants.SASTORE:
//                case Constants.POP:
//                case Constants.POP2:
//                case Constants.DUP:
//                case Constants.DUP_X1:
//                case Constants.DUP_X2:
//                case Constants.DUP2:
//                case Constants.DUP2_X1:
//                case Constants.DUP2_X2:
//                case Constants.SWAP:
//                case Constants.IADD:
//                case Constants.LADD:
//                case Constants.FADD:
//                case Constants.DADD:
//                case Constants.ISUB:
//                case Constants.LSUB:
//                case Constants.FSUB:
//                case Constants.DSUB:
//                case Constants.IMUL:
//                case Constants.LMUL:
//                case Constants.FMUL:
//                case Constants.DMUL:
//                case Constants.IDIV:
//                case Constants.LDIV:
//                case Constants.FDIV:
//                case Constants.DDIV:
//                case Constants.IREM:
//                case Constants.LREM:
//                case Constants.FREM:
//                case Constants.DREM:
//                case Constants.INEG:
//                case Constants.LNEG:
//                case Constants.FNEG:
//                case Constants.DNEG:
//                case Constants.ISHL:
//                case Constants.LSHL:
//                case Constants.ISHR:
//                case Constants.LSHR:
//                case Constants.IUSHR:
//                case Constants.LUSHR:
//                case Constants.IAND:
//                case Constants.LAND:
//                case Constants.IOR:
//                case Constants.LOR:
//                case Constants.IXOR:
//                case Constants.LXOR:
//                case Constants.I2L:
//                case Constants.I2F:
//                case Constants.I2D:
//                case Constants.L2I:
//                case Constants.L2F:
//                case Constants.L2D:
//                case Constants.F2I:
//                case Constants.F2L:
//                case Constants.F2D:
//                case Constants.D2I:
//                case Constants.D2L:
//                case Constants.D2F:
//                case Constants.I2B:
//                case Constants.I2C:
//                case Constants.I2S:
//                case Constants.LCMP:
//                case Constants.FCMPL:
//                case Constants.FCMPG:
//                case Constants.DCMPL:
//                case Constants.DCMPG:
//                case Constants.IRETURN:
//                case Constants.LRETURN:
//                case Constants.FRETURN:
//                case Constants.DRETURN:
//                case Constants.ARETURN:
//                case Constants.RETURN:
//                case Constants.ARRAYLENGTH:
//                case Constants.ATHROW:
//                case Constants.MONITORENTER:
//                case Constants.MONITOREXIT:
//                    methodVisitor.visitInsn(opcode);
//                    currentOffset += 1;
//                    break;
//                case Constants.ILOAD_0:
//                case Constants.ILOAD_1:
//                case Constants.ILOAD_2:
//                case Constants.ILOAD_3:
//                case Constants.LLOAD_0:
//                case Constants.LLOAD_1:
//                case Constants.LLOAD_2:
//                case Constants.LLOAD_3:
//                case Constants.FLOAD_0:
//                case Constants.FLOAD_1:
//                case Constants.FLOAD_2:
//                case Constants.FLOAD_3:
//                case Constants.DLOAD_0:
//                case Constants.DLOAD_1:
//                case Constants.DLOAD_2:
//                case Constants.DLOAD_3:
//                case Constants.ALOAD_0:
//                case Constants.ALOAD_1:
//                case Constants.ALOAD_2:
//                case Constants.ALOAD_3:
//                    opcode -= Constants.ILOAD_0;
//                    methodVisitor.visitVarInsn(Opcodes.ILOAD + (opcode >> 2), opcode & 0x3);
//                    currentOffset += 1;
//                    break;
//                case Constants.ISTORE_0:
//                case Constants.ISTORE_1:
//                case Constants.ISTORE_2:
//                case Constants.ISTORE_3:
//                case Constants.LSTORE_0:
//                case Constants.LSTORE_1:
//                case Constants.LSTORE_2:
//                case Constants.LSTORE_3:
//                case Constants.FSTORE_0:
//                case Constants.FSTORE_1:
//                case Constants.FSTORE_2:
//                case Constants.FSTORE_3:
//                case Constants.DSTORE_0:
//                case Constants.DSTORE_1:
//                case Constants.DSTORE_2:
//                case Constants.DSTORE_3:
//                case Constants.ASTORE_0:
//                case Constants.ASTORE_1:
//                case Constants.ASTORE_2:
//                case Constants.ASTORE_3:
//                    opcode -= Constants.ISTORE_0;
//                    methodVisitor.visitVarInsn(Opcodes.ISTORE + (opcode >> 2), opcode & 0x3);
//                    currentOffset += 1;
//                    break;
//                case Constants.IFEQ:
//                case Constants.IFNE:
//                case Constants.IFLT:
//                case Constants.IFGE:
//                case Constants.IFGT:
//                case Constants.IFLE:
//                case Constants.IF_ICMPEQ:
//                case Constants.IF_ICMPNE:
//                case Constants.IF_ICMPLT:
//                case Constants.IF_ICMPGE:
//                case Constants.IF_ICMPGT:
//                case Constants.IF_ICMPLE:
//                case Constants.IF_ACMPEQ:
//                case Constants.IF_ACMPNE:
//                case Constants.GOTO:
//                case Constants.JSR:
//                case Constants.IFNULL:
//                case Constants.IFNONNULL:
//                    methodVisitor.visitJumpInsn(
//                            opcode, labels[currentBytecodeOffset + readShort(currentOffset + 1)]);
//                    currentOffset += 3;
//                    break;
//                case Constants.GOTO_W:
//                case Constants.JSR_W:
//                    methodVisitor.visitJumpInsn(
//                            opcode - wideJumpOpcodeDelta,
//                            labels[currentBytecodeOffset + readInt(currentOffset + 1)]);
//                    currentOffset += 5;
//                    break;
//                case Constants.ASM_IFEQ:
//                case Constants.ASM_IFNE:
//                case Constants.ASM_IFLT:
//                case Constants.ASM_IFGE:
//                case Constants.ASM_IFGT:
//                case Constants.ASM_IFLE:
//                case Constants.ASM_IF_ICMPEQ:
//                case Constants.ASM_IF_ICMPNE:
//                case Constants.ASM_IF_ICMPLT:
//                case Constants.ASM_IF_ICMPGE:
//                case Constants.ASM_IF_ICMPGT:
//                case Constants.ASM_IF_ICMPLE:
//                case Constants.ASM_IF_ACMPEQ:
//                case Constants.ASM_IF_ACMPNE:
//                case Constants.ASM_GOTO:
//                case Constants.ASM_JSR:
//                case Constants.ASM_IFNULL:
//                case Constants.ASM_IFNONNULL:
//                {
//                    // A forward jump with an offset > 32767. In this case we automatically replace ASM_GOTO
//                    // with GOTO_W, ASM_JSR with JSR_W and ASM_IFxxx <l> with IFNOTxxx <L> GOTO_W <l> L:...,
//                    // where IFNOTxxx is the "opposite" opcode of ASMS_IFxxx (e.g. IFNE for ASM_IFEQ) and
//                    // where <L> designates the instruction just after the GOTO_W.
//                    // First, change the ASM specific opcodes ASM_IFEQ ... ASM_JSR, ASM_IFNULL and
//                    // ASM_IFNONNULL to IFEQ ... JSR, IFNULL and IFNONNULL.
//                    opcode =
//                            opcode < Constants.ASM_IFNULL
//                                    ? opcode - Constants.ASM_OPCODE_DELTA
//                                    : opcode - Constants.ASM_IFNULL_OPCODE_DELTA;
//                    Label target = labels[currentBytecodeOffset + readUnsignedShort(currentOffset + 1)];
//                    if (opcode == Opcodes.GOTO || opcode == Opcodes.JSR) {
//                        // Replace GOTO with GOTO_W and JSR with JSR_W.
//                        methodVisitor.visitJumpInsn(opcode + Constants.WIDE_JUMP_OPCODE_DELTA, target);
//                    } else {
//                        // Compute the "opposite" of opcode. This can be done by flipping the least
//                        // significant bit for IFNULL and IFNONNULL, and similarly for IFEQ ... IF_ACMPEQ
//                        // (with a pre and post offset by 1).
//                        opcode = opcode < Opcodes.GOTO ? ((opcode + 1) ^ 1) - 1 : opcode ^ 1;
//                        Label endif = createLabel(currentBytecodeOffset + 3, labels);
//                        methodVisitor.visitJumpInsn(opcode, endif);
//                        methodVisitor.visitJumpInsn(Constants.GOTO_W, target);
//                        // endif designates the instruction just after GOTO_W, and is visited as part of the
//                        // next instruction. Since it is a jump target, we need to insert a frame here.
//                        insertFrame = true;
//                    }
//                    currentOffset += 3;
//                    break;
//                }
//                case Constants.ASM_GOTO_W:
//                    // Replace ASM_GOTO_W with GOTO_W.
//                    methodVisitor.visitJumpInsn(
//                            Constants.GOTO_W, labels[currentBytecodeOffset + readInt(currentOffset + 1)]);
//                    // The instruction just after is a jump target (because ASM_GOTO_W is used in patterns
//                    // IFNOTxxx <L> ASM_GOTO_W <l> L:..., see MethodWriter), so we need to insert a frame
//                    // here.
//                    insertFrame = true;
//                    currentOffset += 5;
//                    break;
//                case Constants.WIDE:
//                    opcode = classBuffer[currentOffset + 1] & 0xFF;
//                    if (opcode == Opcodes.IINC) {
//                        methodVisitor.visitIincInsn(
//                                readUnsignedShort(currentOffset + 2), readShort(currentOffset + 4));
//                        currentOffset += 6;
//                    } else {
//                        methodVisitor.visitVarInsn(opcode, readUnsignedShort(currentOffset + 2));
//                        currentOffset += 4;
//                    }
//                    break;
//                case Constants.TABLESWITCH:
//                {
//                    // Skip 0 to 3 padding bytes.
//                    currentOffset += 4 - (currentBytecodeOffset & 3);
//                    // Read the instruction.
//                    Label defaultLabel = labels[currentBytecodeOffset + readInt(currentOffset)];
//                    int low = readInt(currentOffset + 4);
//                    int high = readInt(currentOffset + 8);
//                    currentOffset += 12;
//                    Label[] table = new Label[high - low + 1];
//                    for (int i = 0; i < table.length; ++i) {
//                        table[i] = labels[currentBytecodeOffset + readInt(currentOffset)];
//                        currentOffset += 4;
//                    }
//                    methodVisitor.visitTableSwitchInsn(low, high, defaultLabel, table);
//                    break;
//                }
//                case Constants.LOOKUPSWITCH:
//                {
//                    // Skip 0 to 3 padding bytes.
//                    currentOffset += 4 - (currentBytecodeOffset & 3);
//                    // Read the instruction.
//                    Label defaultLabel = labels[currentBytecodeOffset + readInt(currentOffset)];
//                    int numPairs = readInt(currentOffset + 4);
//                    currentOffset += 8;
//                    int[] keys = new int[numPairs];
//                    Label[] values = new Label[numPairs];
//                    for (int i = 0; i < numPairs; ++i) {
//                        keys[i] = readInt(currentOffset);
//                        values[i] = labels[currentBytecodeOffset + readInt(currentOffset + 4)];
//                        currentOffset += 8;
//                    }
//                    methodVisitor.visitLookupSwitchInsn(defaultLabel, keys, values);
//                    break;
//                }
//                case Constants.ILOAD:
//                case Constants.LLOAD:
//                case Constants.FLOAD:
//                case Constants.DLOAD:
//                case Constants.ALOAD:
//                case Constants.ISTORE:
//                case Constants.LSTORE:
//                case Constants.FSTORE:
//                case Constants.DSTORE:
//                case Constants.ASTORE:
//                case Constants.RET:
//                    methodVisitor.visitVarInsn(opcode, classBuffer[currentOffset + 1] & 0xFF);
//                    currentOffset += 2;
//                    break;
//                case Constants.BIPUSH:
//                case Constants.NEWARRAY:
//                    methodVisitor.visitIntInsn(opcode, classBuffer[currentOffset + 1]);
//                    currentOffset += 2;
//                    break;
//                case Constants.SIPUSH:
//                    methodVisitor.visitIntInsn(opcode, readShort(currentOffset + 1));
//                    currentOffset += 3;
//                    break;
//                case Constants.LDC:
//                    methodVisitor.visitLdcInsn(readConst(classBuffer[currentOffset + 1] & 0xFF, charBuffer));
//                    currentOffset += 2;
//                    break;
//                case Constants.LDC_W:
//                case Constants.LDC2_W:
//                    methodVisitor.visitLdcInsn(readConst(readUnsignedShort(currentOffset + 1), charBuffer));
//                    currentOffset += 3;
//                    break;
//                case Constants.GETSTATIC:
//                case Constants.PUTSTATIC:
//                case Constants.GETFIELD:
//                case Constants.PUTFIELD:
//                case Constants.INVOKEVIRTUAL:
//                case Constants.INVOKESPECIAL:
//                case Constants.INVOKESTATIC:
//                case Constants.INVOKEINTERFACE:
//                {
//                    int cpInfoOffset = cpInfoOffsets[readUnsignedShort(currentOffset + 1)];
//                    int nameAndTypeCpInfoOffset = cpInfoOffsets[readUnsignedShort(cpInfoOffset + 2)];
//                    String owner = readClass(cpInfoOffset, charBuffer);
//                    String name = readUTF8(nameAndTypeCpInfoOffset, charBuffer);
//                    String descriptor = readUTF8(nameAndTypeCpInfoOffset + 2, charBuffer);
//                    if (opcode < Opcodes.INVOKEVIRTUAL) {
//                        methodVisitor.visitFieldInsn(opcode, owner, name, descriptor);
//                    } else {
//                        boolean isInterface =
//                                classBuffer[cpInfoOffset - 1] == Symbol.CONSTANT_INTERFACE_METHODREF_TAG;
//                        methodVisitor.visitMethodInsn(opcode, owner, name, descriptor, isInterface);
//                    }
//                    if (opcode == Opcodes.INVOKEINTERFACE) {
//                        currentOffset += 5;
//                    } else {
//                        currentOffset += 3;
//                    }
//                    break;
//                }
//                case Constants.INVOKEDYNAMIC:
//                {
//                    int cpInfoOffset = cpInfoOffsets[readUnsignedShort(currentOffset + 1)];
//                    int nameAndTypeCpInfoOffset = cpInfoOffsets[readUnsignedShort(cpInfoOffset + 2)];
//                    String name = readUTF8(nameAndTypeCpInfoOffset, charBuffer);
//                    String descriptor = readUTF8(nameAndTypeCpInfoOffset + 2, charBuffer);
//                    int bootstrapMethodOffset = bootstrapMethodOffsets[readUnsignedShort(cpInfoOffset)];
//                    Handle handle =
//                            (Handle) readConst(readUnsignedShort(bootstrapMethodOffset), charBuffer);
//                    Object[] bootstrapMethodArguments =
//                            new Object[readUnsignedShort(bootstrapMethodOffset + 2)];
//                    bootstrapMethodOffset += 4;
//                    for (int i = 0; i < bootstrapMethodArguments.length; i++) {
//                        bootstrapMethodArguments[i] =
//                                readConst(readUnsignedShort(bootstrapMethodOffset), charBuffer);
//                        bootstrapMethodOffset += 2;
//                    }
//                    methodVisitor.visitInvokeDynamicInsn(
//                            name, descriptor, handle, bootstrapMethodArguments);
//                    currentOffset += 5;
//                    break;
//                }
//                case Constants.NEW:
//                case Constants.ANEWARRAY:
//                case Constants.CHECKCAST:
//                case Constants.INSTANCEOF:
//                    methodVisitor.visitTypeInsn(opcode, readClass(currentOffset + 1, charBuffer));
//                    currentOffset += 3;
//                    break;
//                case Constants.IINC:
//                    methodVisitor.visitIincInsn(
//                            classBuffer[currentOffset + 1] & 0xFF, classBuffer[currentOffset + 2]);
//                    currentOffset += 3;
//                    break;
//                case Constants.MULTIANEWARRAY:
//                    methodVisitor.visitMultiANewArrayInsn(
//                            readClass(currentOffset + 1, charBuffer), classBuffer[currentOffset + 3] & 0xFF);
//                    currentOffset += 4;
//                    break;
//                default:
//                    throw new AssertionError();
//            }
//
//            // Visit the runtime visible instruction annotations, if any.
//            while (visibleTypeAnnotationOffsets != null
//                    && currentVisibleTypeAnnotationIndex < visibleTypeAnnotationOffsets.length
//                    && currentVisibleTypeAnnotationBytecodeOffset <= currentBytecodeOffset) {
//                if (currentVisibleTypeAnnotationBytecodeOffset == currentBytecodeOffset) {
//                    // Parse the target_type, target_info and target_path fields.
//                    int currentAnnotationOffset =
//                            readTypeAnnotationTarget(
//                                    context, visibleTypeAnnotationOffsets[currentVisibleTypeAnnotationIndex]);
//                    // Parse the type_index field.
//                    String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
//                    currentAnnotationOffset += 2;
//                    // Parse num_element_value_pairs and element_value_pairs and visit these values.
//                    readElementValues(
//                            methodVisitor.visitInsnAnnotation(
//                                    context.currentTypeAnnotationTarget,
//                                    context.currentTypeAnnotationTargetPath,
//                                    annotationDescriptor,
//                                    /* visible = */ true),
//                            currentAnnotationOffset,
//                            /* named = */ true,
//                            charBuffer);
//                }
//                currentVisibleTypeAnnotationBytecodeOffset =
//                        getTypeAnnotationBytecodeOffset(
//                                visibleTypeAnnotationOffsets, ++currentVisibleTypeAnnotationIndex);
//            }
//
//            // Visit the runtime invisible instruction annotations, if any.
//            while (invisibleTypeAnnotationOffsets != null
//                    && currentInvisibleTypeAnnotationIndex < invisibleTypeAnnotationOffsets.length
//                    && currentInvisibleTypeAnnotationBytecodeOffset <= currentBytecodeOffset) {
//                if (currentInvisibleTypeAnnotationBytecodeOffset == currentBytecodeOffset) {
//                    // Parse the target_type, target_info and target_path fields.
//                    int currentAnnotationOffset =
//                            readTypeAnnotationTarget(
//                                    context, invisibleTypeAnnotationOffsets[currentInvisibleTypeAnnotationIndex]);
//                    // Parse the type_index field.
//                    String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
//                    currentAnnotationOffset += 2;
//                    // Parse num_element_value_pairs and element_value_pairs and visit these values.
//                    readElementValues(
//                            methodVisitor.visitInsnAnnotation(
//                                    context.currentTypeAnnotationTarget,
//                                    context.currentTypeAnnotationTargetPath,
//                                    annotationDescriptor,
//                                    /* visible = */ false),
//                            currentAnnotationOffset,
//                            /* named = */ true,
//                            charBuffer);
//                }
//                currentInvisibleTypeAnnotationBytecodeOffset =
//                        getTypeAnnotationBytecodeOffset(
//                                invisibleTypeAnnotationOffsets, ++currentInvisibleTypeAnnotationIndex);
//            }
//        }
//        if (labels[codeLength] != null) {
//            methodVisitor.visitLabel(labels[codeLength]);
//        }
//
//        // Visit LocalVariableTable and LocalVariableTypeTable attributes.
//        if (localVariableTableOffset != 0 && (context.parsingOptions & SKIP_DEBUG) == 0) {
//            // The (start_pc, index, signature_index) fields of each entry of the LocalVariableTypeTable.
//            int[] typeTable = null;
//            if (localVariableTypeTableOffset != 0) {
//                typeTable = new int[readUnsignedShort(localVariableTypeTableOffset) * 3];
//                currentOffset = localVariableTypeTableOffset + 2;
//                int typeTableIndex = typeTable.length;
//                while (typeTableIndex > 0) {
//                    // Store the offset of 'signature_index', and the value of 'index' and 'start_pc'.
//                    typeTable[--typeTableIndex] = currentOffset + 6;
//                    typeTable[--typeTableIndex] = readUnsignedShort(currentOffset + 8);
//                    typeTable[--typeTableIndex] = readUnsignedShort(currentOffset);
//                    currentOffset += 10;
//                }
//            }
//            int localVariableTableLength = readUnsignedShort(localVariableTableOffset);
//            currentOffset = localVariableTableOffset + 2;
//            while (localVariableTableLength-- > 0) {
//                int startPc = readUnsignedShort(currentOffset);
//                int length = readUnsignedShort(currentOffset + 2);
//                String name = readUTF8(currentOffset + 4, charBuffer);
//                String descriptor = readUTF8(currentOffset + 6, charBuffer);
//                int index = readUnsignedShort(currentOffset + 8);
//                currentOffset += 10;
//                String signature = null;
//                if (typeTable != null) {
//                    for (int i = 0; i < typeTable.length; i += 3) {
//                        if (typeTable[i] == startPc && typeTable[i + 1] == index) {
//                            signature = readUTF8(typeTable[i + 2], charBuffer);
//                            break;
//                        }
//                    }
//                }
//                methodVisitor.visitLocalVariable(
//                        name, descriptor, signature, labels[startPc], labels[startPc + length], index);
//            }
//        }
//
//        // Visit the local variable type annotations of the RuntimeVisibleTypeAnnotations attribute.
//        if (visibleTypeAnnotationOffsets != null) {
//            for (int typeAnnotationOffset : visibleTypeAnnotationOffsets) {
//                int targetType = readByte(typeAnnotationOffset);
//                if (targetType == TypeReference.LOCAL_VARIABLE
//                        || targetType == TypeReference.RESOURCE_VARIABLE) {
//                    // Parse the target_type, target_info and target_path fields.
//                    currentOffset = readTypeAnnotationTarget(context, typeAnnotationOffset);
//                    // Parse the type_index field.
//                    String annotationDescriptor = readUTF8(currentOffset, charBuffer);
//                    currentOffset += 2;
//                    // Parse num_element_value_pairs and element_value_pairs and visit these values.
//                    readElementValues(
//                            methodVisitor.visitLocalVariableAnnotation(
//                                    context.currentTypeAnnotationTarget,
//                                    context.currentTypeAnnotationTargetPath,
//                                    context.currentLocalVariableAnnotationRangeStarts,
//                                    context.currentLocalVariableAnnotationRangeEnds,
//                                    context.currentLocalVariableAnnotationRangeIndices,
//                                    annotationDescriptor,
//                                    /* visible = */ true),
//                            currentOffset,
//                            /* named = */ true,
//                            charBuffer);
//                }
//            }
//        }
//
//        // Visit the local variable type annotations of the RuntimeInvisibleTypeAnnotations attribute.
//        if (invisibleTypeAnnotationOffsets != null) {
//            for (int typeAnnotationOffset : invisibleTypeAnnotationOffsets) {
//                int targetType = readByte(typeAnnotationOffset);
//                if (targetType == TypeReference.LOCAL_VARIABLE
//                        || targetType == TypeReference.RESOURCE_VARIABLE) {
//                    // Parse the target_type, target_info and target_path fields.
//                    currentOffset = readTypeAnnotationTarget(context, typeAnnotationOffset);
//                    // Parse the type_index field.
//                    String annotationDescriptor = readUTF8(currentOffset, charBuffer);
//                    currentOffset += 2;
//                    // Parse num_element_value_pairs and element_value_pairs and visit these values.
//                    readElementValues(
//                            methodVisitor.visitLocalVariableAnnotation(
//                                    context.currentTypeAnnotationTarget,
//                                    context.currentTypeAnnotationTargetPath,
//                                    context.currentLocalVariableAnnotationRangeStarts,
//                                    context.currentLocalVariableAnnotationRangeEnds,
//                                    context.currentLocalVariableAnnotationRangeIndices,
//                                    annotationDescriptor,
//                                    /* visible = */ false),
//                            currentOffset,
//                            /* named = */ true,
//                            charBuffer);
//                }
//            }
//        }
//
//        // Visit the non standard attributes.
//        while (attributes != null) {
//            // Copy and reset the nextAttribute field so that it can also be used in MethodWriter.
//            Attribute nextAttribute = attributes.nextAttribute;
//            attributes.nextAttribute = null;
//            methodVisitor.visitAttribute(attributes);
//            attributes = nextAttribute;
//        }
//
//        // Visit the max stack and max locals values.
//        methodVisitor.visitMaxs(maxStack, maxLocals);
//    }
//
//    /**
//     * Returns the label corresponding to the given bytecode offset. The default implementation of
//     * this method creates a label for the given offset if it has not been already created.
//     *
//     * @param bytecodeOffset a bytecode offset in a method.
//     * @param labels the already created labels, indexed by their offset. If a label already exists
//     *     for bytecodeOffset this method must not create a new one. Otherwise it must store the new
//     *     label in this array.
//     * @return a non null Label, which must be equal to labels[bytecodeOffset].
//     */
//    protected Label readLabel(final int bytecodeOffset, final Label[] labels) {
//        // SPRING PATCH: leniently handle offset mismatch
//        if (bytecodeOffset >= labels.length) {
//            return new Label();
//        }
//        // END OF PATCH
//        if (labels[bytecodeOffset] == null) {
//            labels[bytecodeOffset] = new Label();
//        }
//        return labels[bytecodeOffset];
//    }
//
//    /**
//     * Creates a label without the {@link Label#FLAG_DEBUG_ONLY} flag set, for the given bytecode
//     * offset. The label is created with a call to {@link #readLabel} and its {@link
//     * Label#FLAG_DEBUG_ONLY} flag is cleared.
//     *
//     * @param bytecodeOffset a bytecode offset in a method.
//     * @param labels the already created labels, indexed by their offset.
//     * @return a Label without the {@link Label#FLAG_DEBUG_ONLY} flag set.
//     */
//    private Label createLabel(final int bytecodeOffset, final Label[] labels) {
//        Label label = readLabel(bytecodeOffset, labels);
//        label.flags &= ~Label.FLAG_DEBUG_ONLY;
//        return label;
//    }
//
//    /**
//     * Creates a label with the {@link Label#FLAG_DEBUG_ONLY} flag set, if there is no already
//     * existing label for the given bytecode offset (otherwise does nothing). The label is created
//     * with a call to {@link #readLabel}.
//     *
//     * @param bytecodeOffset a bytecode offset in a method.
//     * @param labels the already created labels, indexed by their offset.
//     */
//    private void createDebugLabel(final int bytecodeOffset, final Label[] labels) {
//        if (labels[bytecodeOffset] == null) {
//            readLabel(bytecodeOffset, labels).flags |= Label.FLAG_DEBUG_ONLY;
//        }
//    }
//
//    // ----------------------------------------------------------------------------------------------
//    // Methods to parse annotations, type annotations and parameter annotations
//    // ----------------------------------------------------------------------------------------------
//
//    /**
//     * Parses a Runtime[In]VisibleTypeAnnotations attribute to find the offset of each type_annotation
//     * entry it contains, to find the corresponding labels, and to visit the try catch block
//     * annotations.
//     *
//     * @param methodVisitor the method visitor to be used to visit the try catch block annotations.
//     * @param context information about the class being parsed.
//     * @param runtimeTypeAnnotationsOffset the start offset of a Runtime[In]VisibleTypeAnnotations
//     *     attribute, excluding the attribute_info's attribute_name_index and attribute_length fields.
//     * @param visible true if the attribute to parse is a RuntimeVisibleTypeAnnotations attribute,
//     *     false it is a RuntimeInvisibleTypeAnnotations attribute.
//     * @return the start offset of each entry of the Runtime[In]VisibleTypeAnnotations_attribute's
//     *     'annotations' array field.
//     */
//    private int[] readTypeAnnotations(
//            final MethodVisitor methodVisitor,
//            final Context context,
//            final int runtimeTypeAnnotationsOffset,
//            final boolean visible) {
//        char[] charBuffer = context.charBuffer;
//        int currentOffset = runtimeTypeAnnotationsOffset;
//        // Read the num_annotations field and create an array to store the type_annotation offsets.
//        int[] typeAnnotationsOffsets = new int[readUnsignedShort(currentOffset)];
//        currentOffset += 2;
//        // Parse the 'annotations' array field.
//        for (int i = 0; i < typeAnnotationsOffsets.length; ++i) {
//            typeAnnotationsOffsets[i] = currentOffset;
//            // Parse the type_annotation's target_type and the target_info fields. The size of the
//            // target_info field depends on the value of target_type.
//            int targetType = readInt(currentOffset);
//            switch (targetType >>> 24) {
//                case TypeReference.LOCAL_VARIABLE:
//                case TypeReference.RESOURCE_VARIABLE:
//                    // A localvar_target has a variable size, which depends on the value of their table_length
//                    // field. It also references bytecode offsets, for which we need labels.
//                    int tableLength = readUnsignedShort(currentOffset + 1);
//                    currentOffset += 3;
//                    while (tableLength-- > 0) {
//                        int startPc = readUnsignedShort(currentOffset);
//                        int length = readUnsignedShort(currentOffset + 2);
//                        // Skip the index field (2 bytes).
//                        currentOffset += 6;
//                        createLabel(startPc, context.currentMethodLabels);
//                        createLabel(startPc + length, context.currentMethodLabels);
//                    }
//                    break;
//                case TypeReference.CAST:
//                case TypeReference.CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT:
//                case TypeReference.METHOD_INVOCATION_TYPE_ARGUMENT:
//                case TypeReference.CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT:
//                case TypeReference.METHOD_REFERENCE_TYPE_ARGUMENT:
//                    currentOffset += 4;
//                    break;
//                case TypeReference.CLASS_EXTENDS:
//                case TypeReference.CLASS_TYPE_PARAMETER_BOUND:
//                case TypeReference.METHOD_TYPE_PARAMETER_BOUND:
//                case TypeReference.THROWS:
//                case TypeReference.EXCEPTION_PARAMETER:
//                case TypeReference.INSTANCEOF:
//                case TypeReference.NEW:
//                case TypeReference.CONSTRUCTOR_REFERENCE:
//                case TypeReference.METHOD_REFERENCE:
//                    currentOffset += 3;
//                    break;
//                case TypeReference.CLASS_TYPE_PARAMETER:
//                case TypeReference.METHOD_TYPE_PARAMETER:
//                case TypeReference.METHOD_FORMAL_PARAMETER:
//                case TypeReference.FIELD:
//                case TypeReference.METHOD_RETURN:
//                case TypeReference.METHOD_RECEIVER:
//                default:
//                    // TypeReference type which can't be used in Code attribute, or which is unknown.
//                    throw new IllegalArgumentException();
//            }
//            // Parse the rest of the type_annotation structure, starting with the target_path structure
//            // (whose size depends on its path_length field).
//            int pathLength = readByte(currentOffset);
//            if ((targetType >>> 24) == TypeReference.EXCEPTION_PARAMETER) {
//                // Parse the target_path structure and create a corresponding TypePath.
//                TypePath path = pathLength == 0 ? null : new TypePath(classFileBuffer, currentOffset);
//                currentOffset += 1 + 2 * pathLength;
//                // Parse the type_index field.
//                String annotationDescriptor = readUTF8(currentOffset, charBuffer);
//                currentOffset += 2;
//                // Parse num_element_value_pairs and element_value_pairs and visit these values.
//                currentOffset =
//                        readElementValues(
//                                methodVisitor.visitTryCatchAnnotation(
//                                        targetType & 0xFFFFFF00, path, annotationDescriptor, visible),
//                                currentOffset,
//                                /* named = */ true,
//                                charBuffer);
//            } else {
//                // We don't want to visit the other target_type annotations, so we just skip them (which
//                // requires some parsing because the element_value_pairs array has a variable size). First,
//                // skip the target_path structure:
//                currentOffset += 3 + 2 * pathLength;
//                // Then skip the num_element_value_pairs and element_value_pairs fields (by reading them
//                // with a null AnnotationVisitor).
//                currentOffset =
//                        readElementValues(
//                                /* annotationVisitor = */ null, currentOffset, /* named = */ true, charBuffer);
//            }
//        }
//        return typeAnnotationsOffsets;
//    }
//
//    /**
//     * Returns the bytecode offset corresponding to the specified JVMS 'type_annotation' structure, or
//     * -1 if there is no such type_annotation of if it does not have a bytecode offset.
//     *
//     * @param typeAnnotationOffsets the offset of each 'type_annotation' entry in a
//     *     Runtime[In]VisibleTypeAnnotations attribute, or {@literal null}.
//     * @param typeAnnotationIndex the index a 'type_annotation' entry in typeAnnotationOffsets.
//     * @return bytecode offset corresponding to the specified JVMS 'type_annotation' structure, or -1
//     *     if there is no such type_annotation of if it does not have a bytecode offset.
//     */
//    private int getTypeAnnotationBytecodeOffset(
//            final int[] typeAnnotationOffsets, final int typeAnnotationIndex) {
//        if (typeAnnotationOffsets == null
//                || typeAnnotationIndex >= typeAnnotationOffsets.length
//                || readByte(typeAnnotationOffsets[typeAnnotationIndex]) < TypeReference.INSTANCEOF) {
//            return -1;
//        }
//        return readUnsignedShort(typeAnnotationOffsets[typeAnnotationIndex] + 1);
//    }
//
//    /**
//     * Parses the header of a JVMS type_annotation structure to extract its target_type, target_info
//     * and target_path (the result is stored in the given context), and returns the start offset of
//     * the rest of the type_annotation structure.
//     *
//     * @param context information about the class being parsed. This is where the extracted
//     *     target_type and target_path must be stored.
//     * @param typeAnnotationOffset the start offset of a type_annotation structure.
//     * @return the start offset of the rest of the type_annotation structure.
//     */
//    private int readTypeAnnotationTarget(final Context context, final int typeAnnotationOffset) {
//        int currentOffset = typeAnnotationOffset;
//        // Parse and store the target_type structure.
//        int targetType = readInt(typeAnnotationOffset);
//        switch (targetType >>> 24) {
//            case TypeReference.CLASS_TYPE_PARAMETER:
//            case TypeReference.METHOD_TYPE_PARAMETER:
//            case TypeReference.METHOD_FORMAL_PARAMETER:
//                targetType &= 0xFFFF0000;
//                currentOffset += 2;
//                break;
//            case TypeReference.FIELD:
//            case TypeReference.METHOD_RETURN:
//            case TypeReference.METHOD_RECEIVER:
//                targetType &= 0xFF000000;
//                currentOffset += 1;
//                break;
//            case TypeReference.LOCAL_VARIABLE:
//            case TypeReference.RESOURCE_VARIABLE:
//                targetType &= 0xFF000000;
//                int tableLength = readUnsignedShort(currentOffset + 1);
//                currentOffset += 3;
//                context.currentLocalVariableAnnotationRangeStarts = new Label[tableLength];
//                context.currentLocalVariableAnnotationRangeEnds = new Label[tableLength];
//                context.currentLocalVariableAnnotationRangeIndices = new int[tableLength];
//                for (int i = 0; i < tableLength; ++i) {
//                    int startPc = readUnsignedShort(currentOffset);
//                    int length = readUnsignedShort(currentOffset + 2);
//                    int index = readUnsignedShort(currentOffset + 4);
//                    currentOffset += 6;
//                    context.currentLocalVariableAnnotationRangeStarts[i] =
//                            createLabel(startPc, context.currentMethodLabels);
//                    context.currentLocalVariableAnnotationRangeEnds[i] =
//                            createLabel(startPc + length, context.currentMethodLabels);
//                    context.currentLocalVariableAnnotationRangeIndices[i] = index;
//                }
//                break;
//            case TypeReference.CAST:
//            case TypeReference.CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT:
//            case TypeReference.METHOD_INVOCATION_TYPE_ARGUMENT:
//            case TypeReference.CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT:
//            case TypeReference.METHOD_REFERENCE_TYPE_ARGUMENT:
//                targetType &= 0xFF0000FF;
//                currentOffset += 4;
//                break;
//            case TypeReference.CLASS_EXTENDS:
//            case TypeReference.CLASS_TYPE_PARAMETER_BOUND:
//            case TypeReference.METHOD_TYPE_PARAMETER_BOUND:
//            case TypeReference.THROWS:
//            case TypeReference.EXCEPTION_PARAMETER:
//                targetType &= 0xFFFFFF00;
//                currentOffset += 3;
//                break;
//            case TypeReference.INSTANCEOF:
//            case TypeReference.NEW:
//            case TypeReference.CONSTRUCTOR_REFERENCE:
//            case TypeReference.METHOD_REFERENCE:
//                targetType &= 0xFF000000;
//                currentOffset += 3;
//                break;
//            default:
//                throw new IllegalArgumentException();
//        }
//        context.currentTypeAnnotationTarget = targetType;
//        // Parse and store the target_path structure.
//        int pathLength = readByte(currentOffset);
//        context.currentTypeAnnotationTargetPath =
//                pathLength == 0 ? null : new TypePath(classFileBuffer, currentOffset);
//        // Return the start offset of the rest of the type_annotation structure.
//        return currentOffset + 1 + 2 * pathLength;
//    }
//
//    /**
//     * Reads a Runtime[In]VisibleParameterAnnotations attribute and makes the given visitor visit it.
//     *
//     * @param methodVisitor the visitor that must visit the parameter annotations.
//     * @param context information about the class being parsed.
//     * @param runtimeParameterAnnotationsOffset the start offset of a
//     *     Runtime[In]VisibleParameterAnnotations attribute, excluding the attribute_info's
//     *     attribute_name_index and attribute_length fields.
//     * @param visible true if the attribute to parse is a RuntimeVisibleParameterAnnotations
//     *     attribute, false it is a RuntimeInvisibleParameterAnnotations attribute.
//     */
//    private void readParameterAnnotations(
//            final MethodVisitor methodVisitor,
//            final Context context,
//            final int runtimeParameterAnnotationsOffset,
//            final boolean visible) {
//        int currentOffset = runtimeParameterAnnotationsOffset;
//        int numParameters = classFileBuffer[currentOffset++] & 0xFF;
//        methodVisitor.visitAnnotableParameterCount(numParameters, visible);
//        char[] charBuffer = context.charBuffer;
//        for (int i = 0; i < numParameters; ++i) {
//            int numAnnotations = readUnsignedShort(currentOffset);
//            currentOffset += 2;
//            while (numAnnotations-- > 0) {
//                // Parse the type_index field.
//                String annotationDescriptor = readUTF8(currentOffset, charBuffer);
//                currentOffset += 2;
//                // Parse num_element_value_pairs and element_value_pairs and visit these values.
//                currentOffset =
//                        readElementValues(
//                                methodVisitor.visitParameterAnnotation(i, annotationDescriptor, visible),
//                                currentOffset,
//                                /* named = */ true,
//                                charBuffer);
//            }
//        }
//    }
//
//    /**
//     * Reads the element values of a JVMS 'annotation' structure and makes the given visitor visit
//     * them. This method can also be used to read the values of the JVMS 'array_value' field of an
//     * annotation's 'element_value'.
//     *
//     * @param annotationVisitor the visitor that must visit the values.
//     * @param annotationOffset the start offset of an 'annotation' structure (excluding its type_index
//     *     field) or of an 'array_value' structure.
//     * @param named if the annotation values are named or not. This should be true to parse the values
//     *     of a JVMS 'annotation' structure, and false to parse the JVMS 'array_value' of an
//     *     annotation's element_value.
//     * @param charBuffer the buffer used to read strings in the constant pool.
//     * @return the end offset of the JVMS 'annotation' or 'array_value' structure.
//     */
//    private int readElementValues(
//            final AnnotationVisitor annotationVisitor,
//            final int annotationOffset,
//            final boolean named,
//            final char[] charBuffer) {
//        int currentOffset = annotationOffset;
//        // Read the num_element_value_pairs field (or num_values field for an array_value).
//        int numElementValuePairs = readUnsignedShort(currentOffset);
//        currentOffset += 2;
//        if (named) {
//            // Parse the element_value_pairs array.
//            while (numElementValuePairs-- > 0) {
//                String elementName = readUTF8(currentOffset, charBuffer);
//                currentOffset =
//                        readElementValue(annotationVisitor, currentOffset + 2, elementName, charBuffer);
//            }
//        } else {
//            // Parse the array_value array.
//            while (numElementValuePairs-- > 0) {
//                currentOffset =
//                        readElementValue(annotationVisitor, currentOffset, /* named = */ null, charBuffer);
//            }
//        }
//        if (annotationVisitor != null) {
//            annotationVisitor.visitEnd();
//        }
//        return currentOffset;
//    }
//
//    /**
//     * Reads a JVMS 'element_value' structure and makes the given visitor visit it.
//     *
//     * @param annotationVisitor the visitor that must visit the element_value structure.
//     * @param elementValueOffset the start offset in {@link #classFileBuffer} of the element_value
//     *     structure to be read.
//     * @param elementName the name of the element_value structure to be read, or {@literal null}.
//     * @param charBuffer the buffer used to read strings in the constant pool.
//     * @return the end offset of the JVMS 'element_value' structure.
//     */
//    private int readElementValue(
//            final AnnotationVisitor annotationVisitor,
//            final int elementValueOffset,
//            final String elementName,
//            final char[] charBuffer) {
//        int currentOffset = elementValueOffset;
//        if (annotationVisitor == null) {
//            switch (classFileBuffer[currentOffset] & 0xFF) {
//                case 'e': // enum_const_value
//                    return currentOffset + 5;
//                case '@': // annotation_value
//                    return readElementValues(null, currentOffset + 3, /* named = */ true, charBuffer);
//                case '[': // array_value
//                    return readElementValues(null, currentOffset + 1, /* named = */ false, charBuffer);
//                default:
//                    return currentOffset + 3;
//            }
//        }
//        switch (classFileBuffer[currentOffset++] & 0xFF) {
//            case 'B': // const_value_index, CONSTANT_Integer
//                annotationVisitor.visit(
//                        elementName, (byte) readInt(cpInfoOffsets[readUnsignedShort(currentOffset)]));
//                currentOffset += 2;
//                break;
//            case 'C': // const_value_index, CONSTANT_Integer
//                annotationVisitor.visit(
//                        elementName, (char) readInt(cpInfoOffsets[readUnsignedShort(currentOffset)]));
//                currentOffset += 2;
//                break;
//            case 'D': // const_value_index, CONSTANT_Double
//            case 'F': // const_value_index, CONSTANT_Float
//            case 'I': // const_value_index, CONSTANT_Integer
//            case 'J': // const_value_index, CONSTANT_Long
//                annotationVisitor.visit(
//                        elementName, readConst(readUnsignedShort(currentOffset), charBuffer));
//                currentOffset += 2;
//                break;
//            case 'S': // const_value_index, CONSTANT_Integer
//                annotationVisitor.visit(
//                        elementName, (short) readInt(cpInfoOffsets[readUnsignedShort(currentOffset)]));
//                currentOffset += 2;
//                break;
//
//            case 'Z': // const_value_index, CONSTANT_Integer
//                annotationVisitor.visit(
//                        elementName,
//                        readInt(cpInfoOffsets[readUnsignedShort(currentOffset)]) == 0
//                                ? Boolean.FALSE
//                                : Boolean.TRUE);
//                currentOffset += 2;
//                break;
//            case 's': // const_value_index, CONSTANT_Utf8
//                annotationVisitor.visit(elementName, readUTF8(currentOffset, charBuffer));
//                currentOffset += 2;
//                break;
//            case 'e': // enum_const_value
//                annotationVisitor.visitEnum(
//                        elementName,
//                        readUTF8(currentOffset, charBuffer),
//                        readUTF8(currentOffset + 2, charBuffer));
//                currentOffset += 4;
//                break;
//            case 'c': // class_info
//                annotationVisitor.visit(elementName, Type.getType(readUTF8(currentOffset, charBuffer)));
//                currentOffset += 2;
//                break;
//            case '@': // annotation_value
//                currentOffset =
//                        readElementValues(
//                                annotationVisitor.visitAnnotation(elementName, readUTF8(currentOffset, charBuffer)),
//                                currentOffset + 2,
//                                true,
//                                charBuffer);
//                break;
//            case '[': // array_value
//                int numValues = readUnsignedShort(currentOffset);
//                currentOffset += 2;
//                if (numValues == 0) {
//                    return readElementValues(
//                            annotationVisitor.visitArray(elementName),
//                            currentOffset - 2,
//                            /* named = */ false,
//                            charBuffer);
//                }
//                switch (classFileBuffer[currentOffset] & 0xFF) {
//                    case 'B':
//                        byte[] byteValues = new byte[numValues];
//                        for (int i = 0; i < numValues; i++) {
//                            byteValues[i] = (byte) readInt(cpInfoOffsets[readUnsignedShort(currentOffset + 1)]);
//                            currentOffset += 3;
//                        }
//                        annotationVisitor.visit(elementName, byteValues);
//                        break;
//                    case 'Z':
//                        boolean[] booleanValues = new boolean[numValues];
//                        for (int i = 0; i < numValues; i++) {
//                            booleanValues[i] = readInt(cpInfoOffsets[readUnsignedShort(currentOffset + 1)]) != 0;
//                            currentOffset += 3;
//                        }
//                        annotationVisitor.visit(elementName, booleanValues);
//                        break;
//                    case 'S':
//                        short[] shortValues = new short[numValues];
//                        for (int i = 0; i < numValues; i++) {
//                            shortValues[i] = (short) readInt(cpInfoOffsets[readUnsignedShort(currentOffset + 1)]);
//                            currentOffset += 3;
//                        }
//                        annotationVisitor.visit(elementName, shortValues);
//                        break;
//                    case 'C':
//                        char[] charValues = new char[numValues];
//                        for (int i = 0; i < numValues; i++) {
//                            charValues[i] = (char) readInt(cpInfoOffsets[readUnsignedShort(currentOffset + 1)]);
//                            currentOffset += 3;
//                        }
//                        annotationVisitor.visit(elementName, charValues);
//                        break;
//                    case 'I':
//                        int[] intValues = new int[numValues];
//                        for (int i = 0; i < numValues; i++) {
//                            intValues[i] = readInt(cpInfoOffsets[readUnsignedShort(currentOffset + 1)]);
//                            currentOffset += 3;
//                        }
//                        annotationVisitor.visit(elementName, intValues);
//                        break;
//                    case 'J':
//                        long[] longValues = new long[numValues];
//                        for (int i = 0; i < numValues; i++) {
//                            longValues[i] = readLong(cpInfoOffsets[readUnsignedShort(currentOffset + 1)]);
//                            currentOffset += 3;
//                        }
//                        annotationVisitor.visit(elementName, longValues);
//                        break;
//                    case 'F':
//                        float[] floatValues = new float[numValues];
//                        for (int i = 0; i < numValues; i++) {
//                            floatValues[i] =
//                                    Float.intBitsToFloat(
//                                            readInt(cpInfoOffsets[readUnsignedShort(currentOffset + 1)]));
//                            currentOffset += 3;
//                        }
//                        annotationVisitor.visit(elementName, floatValues);
//                        break;
//                    case 'D':
//                        double[] doubleValues = new double[numValues];
//                        for (int i = 0; i < numValues; i++) {
//                            doubleValues[i] =
//                                    Double.longBitsToDouble(
//                                            readLong(cpInfoOffsets[readUnsignedShort(currentOffset + 1)]));
//                            currentOffset += 3;
//                        }
//                        annotationVisitor.visit(elementName, doubleValues);
//                        break;
//                    default:
//                        currentOffset =
//                                readElementValues(
//                                        annotationVisitor.visitArray(elementName),
//                                        currentOffset - 2,
//                                        /* named = */ false,
//                                        charBuffer);
//                        break;
//                }
//                break;
//            default:
//                throw new IllegalArgumentException();
//        }
//        return currentOffset;
//    }
//
//    // ----------------------------------------------------------------------------------------------
//    // Methods to parse stack map frames
//    // ----------------------------------------------------------------------------------------------
//
//    /**
//     * Computes the implicit frame of the method currently being parsed (as defined in the given
//     * {@link Context}) and stores it in the given context.
//     *
//     * @param context information about the class being parsed.
//     */
//    private void computeImplicitFrame(final Context context) {
//        String methodDescriptor = context.currentMethodDescriptor;
//        Object[] locals = context.currentFrameLocalTypes;
//        int numLocal = 0;
//        if ((context.currentMethodAccessFlags & Opcodes.ACC_STATIC) == 0) {
//            if ("<init>".equals(context.currentMethodName)) {
//                locals[numLocal++] = Opcodes.UNINITIALIZED_THIS;
//            } else {
//                locals[numLocal++] = readClass(header + 2, context.charBuffer);
//            }
//        }
//        // Parse the method descriptor, one argument type descriptor at each iteration. Start by
//        // skipping the first method descriptor character, which is always '('.
//        int currentMethodDescritorOffset = 1;
//        while (true) {
//            int currentArgumentDescriptorStartOffset = currentMethodDescritorOffset;
//            switch (methodDescriptor.charAt(currentMethodDescritorOffset++)) {
//                case 'Z':
//                case 'C':
//                case 'B':
//                case 'S':
//                case 'I':
//                    locals[numLocal++] = Opcodes.INTEGER;
//                    break;
//                case 'F':
//                    locals[numLocal++] = Opcodes.FLOAT;
//                    break;
//                case 'J':
//                    locals[numLocal++] = Opcodes.LONG;
//                    break;
//                case 'D':
//                    locals[numLocal++] = Opcodes.DOUBLE;
//                    break;
//                case '[':
//                    while (methodDescriptor.charAt(currentMethodDescritorOffset) == '[') {
//                        ++currentMethodDescritorOffset;
//                    }
//                    if (methodDescriptor.charAt(currentMethodDescritorOffset) == 'L') {
//                        ++currentMethodDescritorOffset;
//                        while (methodDescriptor.charAt(currentMethodDescritorOffset) != ';') {
//                            ++currentMethodDescritorOffset;
//                        }
//                    }
//                    locals[numLocal++] =
//                            methodDescriptor.substring(
//                                    currentArgumentDescriptorStartOffset, ++currentMethodDescritorOffset);
//                    break;
//                case 'L':
//                    while (methodDescriptor.charAt(currentMethodDescritorOffset) != ';') {
//                        ++currentMethodDescritorOffset;
//                    }
//                    locals[numLocal++] =
//                            methodDescriptor.substring(
//                                    currentArgumentDescriptorStartOffset + 1, currentMethodDescritorOffset++);
//                    break;
//                default:
//                    context.currentFrameLocalCount = numLocal;
//                    return;
//            }
//        }
//    }
//
//    /**
//     * Reads a JVMS 'stack_map_frame' structure and stores the result in the given {@link Context}
//     * object. This method can also be used to read a full_frame structure, excluding its frame_type
//     * field (this is used to parse the legacy StackMap attributes).
//     *
//     * @param stackMapFrameOffset the start offset in {@link #classFileBuffer} of the
//     *     stack_map_frame_value structure to be read, or the start offset of a full_frame structure
//     *     (excluding its frame_type field).
//     * @param compressed true to read a 'stack_map_frame' structure, false to read a 'full_frame'
//     *     structure without its frame_type field.
//     * @param expand if the stack map frame must be expanded. See {@link #EXPAND_FRAMES}.
//     * @param context where the parsed stack map frame must be stored.
//     * @return the end offset of the JVMS 'stack_map_frame' or 'full_frame' structure.
//     */
//    private int readStackMapFrame(
//            final int stackMapFrameOffset,
//            final boolean compressed,
//            final boolean expand,
//            final Context context) {
//        int currentOffset = stackMapFrameOffset;
//        final char[] charBuffer = context.charBuffer;
//        final Label[] labels = context.currentMethodLabels;
//        int frameType;
//        if (compressed) {
//            // Read the frame_type field.
//            frameType = classFileBuffer[currentOffset++] & 0xFF;
//        } else {
//            frameType = Frame.FULL_FRAME;
//            context.currentFrameOffset = -1;
//        }
//        int offsetDelta;
//        context.currentFrameLocalCountDelta = 0;
//        if (frameType < Frame.SAME_LOCALS_1_STACK_ITEM_FRAME) {
//            offsetDelta = frameType;
//            context.currentFrameType = Opcodes.F_SAME;
//            context.currentFrameStackCount = 0;
//        } else if (frameType < Frame.RESERVED) {
//            offsetDelta = frameType - Frame.SAME_LOCALS_1_STACK_ITEM_FRAME;
//            currentOffset =
//                    readVerificationTypeInfo(
//                            currentOffset, context.currentFrameStackTypes, 0, charBuffer, labels);
//            context.currentFrameType = Opcodes.F_SAME1;
//            context.currentFrameStackCount = 1;
//        } else if (frameType >= Frame.SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED) {
//            offsetDelta = readUnsignedShort(currentOffset);
//            currentOffset += 2;
//            if (frameType == Frame.SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED) {
//                currentOffset =
//                        readVerificationTypeInfo(
//                                currentOffset, context.currentFrameStackTypes, 0, charBuffer, labels);
//                context.currentFrameType = Opcodes.F_SAME1;
//                context.currentFrameStackCount = 1;
//            } else if (frameType >= Frame.CHOP_FRAME && frameType < Frame.SAME_FRAME_EXTENDED) {
//                context.currentFrameType = Opcodes.F_CHOP;
//                context.currentFrameLocalCountDelta = Frame.SAME_FRAME_EXTENDED - frameType;
//                context.currentFrameLocalCount -= context.currentFrameLocalCountDelta;
//                context.currentFrameStackCount = 0;
//            } else if (frameType == Frame.SAME_FRAME_EXTENDED) {
//                context.currentFrameType = Opcodes.F_SAME;
//                context.currentFrameStackCount = 0;
//            } else if (frameType < Frame.FULL_FRAME) {
//                int local = expand ? context.currentFrameLocalCount : 0;
//                for (int k = frameType - Frame.SAME_FRAME_EXTENDED; k > 0; k--) {
//                    currentOffset =
//                            readVerificationTypeInfo(
//                                    currentOffset, context.currentFrameLocalTypes, local++, charBuffer, labels);
//                }
//                context.currentFrameType = Opcodes.F_APPEND;
//                context.currentFrameLocalCountDelta = frameType - Frame.SAME_FRAME_EXTENDED;
//                context.currentFrameLocalCount += context.currentFrameLocalCountDelta;
//                context.currentFrameStackCount = 0;
//            } else {
//                final int numberOfLocals = readUnsignedShort(currentOffset);
//                currentOffset += 2;
//                context.currentFrameType = Opcodes.F_FULL;
//                context.currentFrameLocalCountDelta = numberOfLocals;
//                context.currentFrameLocalCount = numberOfLocals;
//                for (int local = 0; local < numberOfLocals; ++local) {
//                    currentOffset =
//                            readVerificationTypeInfo(
//                                    currentOffset, context.currentFrameLocalTypes, local, charBuffer, labels);
//                }
//                final int numberOfStackItems = readUnsignedShort(currentOffset);
//                currentOffset += 2;
//                context.currentFrameStackCount = numberOfStackItems;
//                for (int stack = 0; stack < numberOfStackItems; ++stack) {
//                    currentOffset =
//                            readVerificationTypeInfo(
//                                    currentOffset, context.currentFrameStackTypes, stack, charBuffer, labels);
//                }
//            }
//        } else {
//            throw new IllegalArgumentException();
//        }
//        context.currentFrameOffset += offsetDelta + 1;
//        createLabel(context.currentFrameOffset, labels);
//        return currentOffset;
//    }
//
//    /**
//     * Reads a JVMS 'verification_type_info' structure and stores it at the given index in the given
//     * array.
//     *
//     * @param verificationTypeInfoOffset the start offset of the 'verification_type_info' structure to
//     *     read.
//     * @param frame the array where the parsed type must be stored.
//     * @param index the index in 'frame' where the parsed type must be stored.
//     * @param charBuffer the buffer used to read strings in the constant pool.
//     * @param labels the labels of the method currently being parsed, indexed by their offset. If the
//     *     parsed type is an ITEM_Uninitialized, a new label for the corresponding NEW instruction is
//     *     stored in this array if it does not already exist.
//     * @return the end offset of the JVMS 'verification_type_info' structure.
//     */
//    private int readVerificationTypeInfo(
//            final int verificationTypeInfoOffset,
//            final Object[] frame,
//            final int index,
//            final char[] charBuffer,
//            final Label[] labels) {
//        int currentOffset = verificationTypeInfoOffset;
//        int tag = classFileBuffer[currentOffset++] & 0xFF;
//        switch (tag) {
//            case Frame.ITEM_TOP:
//                frame[index] = Opcodes.TOP;
//                break;
//            case Frame.ITEM_INTEGER:
//                frame[index] = Opcodes.INTEGER;
//                break;
//            case Frame.ITEM_FLOAT:
//                frame[index] = Opcodes.FLOAT;
//                break;
//            case Frame.ITEM_DOUBLE:
//                frame[index] = Opcodes.DOUBLE;
//                break;
//            case Frame.ITEM_LONG:
//                frame[index] = Opcodes.LONG;
//                break;
//            case Frame.ITEM_NULL:
//                frame[index] = Opcodes.NULL;
//                break;
//            case Frame.ITEM_UNINITIALIZED_THIS:
//                frame[index] = Opcodes.UNINITIALIZED_THIS;
//                break;
//            case Frame.ITEM_OBJECT:
//                frame[index] = readClass(currentOffset, charBuffer);
//                currentOffset += 2;
//                break;
//            case Frame.ITEM_UNINITIALIZED:
//                frame[index] = createLabel(readUnsignedShort(currentOffset), labels);
//                currentOffset += 2;
//                break;
//            default:
//                throw new IllegalArgumentException();
//        }
//        return currentOffset;
//    }
//
//    // ----------------------------------------------------------------------------------------------
//    // Methods to parse attributes
//    // ----------------------------------------------------------------------------------------------
//
//    /**
//     * Returns the offset in {@link #classFileBuffer} of the first ClassFile's 'attributes' array
//     * field entry.
//     *
//     * @return the offset in {@link #classFileBuffer} of the first ClassFile's 'attributes' array
//     *     field entry.
//     */
//    final int getFirstAttributeOffset() {
//        // Skip the access_flags, this_class, super_class, and interfaces_count fields (using 2 bytes
//        // each), as well as the interfaces array field (2 bytes per interface).
//        int currentOffset = header + 8 + readUnsignedShort(header + 6) * 2;
//
//        // Read the fields_count field.
//        int fieldsCount = readUnsignedShort(currentOffset);
//        currentOffset += 2;
//        // Skip the 'fields' array field.
//        while (fieldsCount-- > 0) {
//            // Invariant: currentOffset is the offset of a field_info structure.
//            // Skip the access_flags, name_index and descriptor_index fields (2 bytes each), and read the
//            // attributes_count field.
//            int attributesCount = readUnsignedShort(currentOffset + 6);
//            currentOffset += 8;
//            // Skip the 'attributes' array field.
//            while (attributesCount-- > 0) {
//                // Invariant: currentOffset is the offset of an attribute_info structure.
//                // Read the attribute_length field (2 bytes after the start of the attribute_info) and skip
//                // this many bytes, plus 6 for the attribute_name_index and attribute_length fields
//                // (yielding the total size of the attribute_info structure).
//                currentOffset += 6 + readInt(currentOffset + 2);
//            }
//        }
//
//        // Skip the methods_count and 'methods' fields, using the same method as above.
//        int methodsCount = readUnsignedShort(currentOffset);
//        currentOffset += 2;
//        while (methodsCount-- > 0) {
//            int attributesCount = readUnsignedShort(currentOffset + 6);
//            currentOffset += 8;
//            while (attributesCount-- > 0) {
//                currentOffset += 6 + readInt(currentOffset + 2);
//            }
//        }
//
//        // Skip the ClassFile's attributes_count field.
//        return currentOffset + 2;
//    }
//
//    /**
//     * Reads the BootstrapMethods attribute to compute the offset of each bootstrap method.
//     *
//     * @param maxStringLength a conservative estimate of the maximum length of the strings contained
//     *     in the constant pool of the class.
//     * @return the offsets of the bootstrap methods.
//     */
//    private int[] readBootstrapMethodsAttribute(final int maxStringLength) {
//        char[] charBuffer = new char[maxStringLength];
//        int currentAttributeOffset = getFirstAttributeOffset();
//        int[] currentBootstrapMethodOffsets = null;
//        for (int i = readUnsignedShort(currentAttributeOffset - 2); i > 0; --i) {
//            // Read the attribute_info's attribute_name and attribute_length fields.
//            String attributeName = readUTF8(currentAttributeOffset, charBuffer);
//            int attributeLength = readInt(currentAttributeOffset + 2);
//            currentAttributeOffset += 6;
//            if (Constants.BOOTSTRAP_METHODS.equals(attributeName)) {
//                // Read the num_bootstrap_methods field and create an array of this size.
//                currentBootstrapMethodOffsets = new int[readUnsignedShort(currentAttributeOffset)];
//                // Compute and store the offset of each 'bootstrap_methods' array field entry.
//                int currentBootstrapMethodOffset = currentAttributeOffset + 2;
//                for (int j = 0; j < currentBootstrapMethodOffsets.length; ++j) {
//                    currentBootstrapMethodOffsets[j] = currentBootstrapMethodOffset;
//                    // Skip the bootstrap_method_ref and num_bootstrap_arguments fields (2 bytes each),
//                    // as well as the bootstrap_arguments array field (of size num_bootstrap_arguments * 2).
//                    currentBootstrapMethodOffset +=
//                            4 + readUnsignedShort(currentBootstrapMethodOffset + 2) * 2;
//                }
//                return currentBootstrapMethodOffsets;
//            }
//            currentAttributeOffset += attributeLength;
//        }
//        throw new IllegalArgumentException();
//    }
//
//    /**
//     * Reads a non standard JVMS 'attribute' structure in {@link #classFileBuffer}.
//     *
//     * @param attributePrototypes prototypes of the attributes that must be parsed during the visit of
//     *     the class. Any attribute whose type is not equal to the type of one the prototypes will not
//     *     be parsed: its byte array value will be passed unchanged to the ClassWriter.
//     * @param type the type of the attribute.
//     * @param offset the start offset of the JVMS 'attribute' structure in {@link #classFileBuffer}.
//     *     The 6 attribute header bytes (attribute_name_index and attribute_length) are not taken into
//     *     account here.
//     * @param length the length of the attribute's content (excluding the 6 attribute header bytes).
//     * @param charBuffer the buffer to be used to read strings in the constant pool.
//     * @param codeAttributeOffset the start offset of the enclosing Code attribute in {@link
//     *     #classFileBuffer}, or -1 if the attribute to be read is not a code attribute. The 6
//     *     attribute header bytes (attribute_name_index and attribute_length) are not taken into
//     *     account here.
//     * @param labels the labels of the method's code, or {@literal null} if the attribute to be read
//     *     is not a code attribute.
//     * @return the attribute that has been read.
//     */
//    private Attribute readAttribute(
//            final Attribute[] attributePrototypes,
//            final String type,
//            final int offset,
//            final int length,
//            final char[] charBuffer,
//            final int codeAttributeOffset,
//            final Label[] labels) {
//        for (Attribute attributePrototype : attributePrototypes) {
//            if (attributePrototype.type.equals(type)) {
//                return attributePrototype.read(
//                        this, offset, length, charBuffer, codeAttributeOffset, labels);
//            }
//        }
//        return new Attribute(type).read(this, offset, length, null, -1, null);
//    }
//
//    // -----------------------------------------------------------------------------------------------
//    // Utility methods: low level parsing
//    // -----------------------------------------------------------------------------------------------
//
//    /**
//     * Returns the number of entries in the class's constant pool table.
//     *
//     * @return the number of entries in the class's constant pool table.
//     */
//    public int getItemCount() {
//        return cpInfoOffsets.length;
//    }
//
//    /**
//     * Returns the start offset in this {@link ClassReader} of a JVMS 'cp_info' structure (i.e. a
//     * constant pool entry), plus one. <i>This method is intended for {@link Attribute} sub classes,
//     * and is normally not needed by class generators or adapters.</i>
//     *
//     * @param constantPoolEntryIndex the index a constant pool entry in the class's constant pool
//     *     table.
//     * @return the start offset in this {@link ClassReader} of the corresponding JVMS 'cp_info'
//     *     structure, plus one.
//     */
//    public int getItem(final int constantPoolEntryIndex) {
//        return cpInfoOffsets[constantPoolEntryIndex];
//    }
//
//    /**
//     * Returns a conservative estimate of the maximum length of the strings contained in the class's
//     * constant pool table.
//     *
//     * @return a conservative estimate of the maximum length of the strings contained in the class's
//     *     constant pool table.
//     */
//    public int getMaxStringLength() {
//        return maxStringLength;
//    }
//
//    /**
//     * Reads a byte value in this {@link ClassReader}. <i>This method is intended for {@link
//     * Attribute} sub classes, and is normally not needed by class generators or adapters.</i>
//     *
//     * @param offset the start offset of the value to be read in this {@link ClassReader}.
//     * @return the read value.
//     */
//    public int readByte(final int offset) {
//        return classFileBuffer[offset] & 0xFF;
//    }
//
//    /**
//     * Reads an unsigned short value in this {@link ClassReader}. <i>This method is intended for
//     * {@link Attribute} sub classes, and is normally not needed by class generators or adapters.</i>
//     *
//     * @param offset the start index of the value to be read in this {@link ClassReader}.
//     * @return the read value.
//     */
//    public int readUnsignedShort(final int offset) {
//        byte[] classBuffer = classFileBuffer;
//        return ((classBuffer[offset] & 0xFF) << 8) | (classBuffer[offset + 1] & 0xFF);
//    }
//
//    /**
//     * Reads a signed short value in this {@link ClassReader}. <i>This method is intended for {@link
//     * Attribute} sub classes, and is normally not needed by class generators or adapters.</i>
//     *
//     * @param offset the start offset of the value to be read in this {@link ClassReader}.
//     * @return the read value.
//     */
//    public short readShort(final int offset) {
//        byte[] classBuffer = classFileBuffer;
//        return (short) (((classBuffer[offset] & 0xFF) << 8) | (classBuffer[offset + 1] & 0xFF));
//    }
//
//    /**
//     * Reads a signed int value in this {@link ClassReader}. <i>This method is intended for {@link
//     * Attribute} sub classes, and is normally not needed by class generators or adapters.</i>
//     *
//     * @param offset the start offset of the value to be read in this {@link ClassReader}.
//     * @return the read value.
//     */
//    public int readInt(final int offset) {
//        byte[] classBuffer = classFileBuffer;
//        return ((classBuffer[offset] & 0xFF) << 24)
//                | ((classBuffer[offset + 1] & 0xFF) << 16)
//                | ((classBuffer[offset + 2] & 0xFF) << 8)
//                | (classBuffer[offset + 3] & 0xFF);
//    }
//
//    /**
//     * Reads a signed long value in this {@link ClassReader}. <i>This method is intended for {@link
//     * Attribute} sub classes, and is normally not needed by class generators or adapters.</i>
//     *
//     * @param offset the start offset of the value to be read in this {@link ClassReader}.
//     * @return the read value.
//     */
//    public long readLong(final int offset) {
//        long l1 = readInt(offset);
//        long l0 = readInt(offset + 4) & 0xFFFFFFFFL;
//        return (l1 << 32) | l0;
//    }
//
//    /**
//     * Reads a CONSTANT_Utf8 constant pool entry in this {@link ClassReader}. <i>This method is
//     * intended for {@link Attribute} sub classes, and is normally not needed by class generators or
//     * adapters.</i>
//     *
//     * @param offset the start offset of an unsigned short value in this {@link ClassReader}, whose
//     *     value is the index of a CONSTANT_Utf8 entry in the class's constant pool table.
//     * @param charBuffer the buffer to be used to read the string. This buffer must be sufficiently
//     *     large. It is not automatically resized.
//     * @return the String corresponding to the specified CONSTANT_Utf8 entry.
//     */
//    // DontCheck(AbbreviationAsWordInName): can't be renamed (for backward binary compatibility).
//    public String readUTF8(final int offset, final char[] charBuffer) {
//        int constantPoolEntryIndex = readUnsignedShort(offset);
//        if (offset == 0 || constantPoolEntryIndex == 0) {
//            return null;
//        }
//        return readUtf(constantPoolEntryIndex, charBuffer);
//    }
//
//    /**
//     * Reads a CONSTANT_Utf8 constant pool entry in {@link #classFileBuffer}.
//     *
//     * @param constantPoolEntryIndex the index of a CONSTANT_Utf8 entry in the class's constant pool
//     *     table.
//     * @param charBuffer the buffer to be used to read the string. This buffer must be sufficiently
//     *     large. It is not automatically resized.
//     * @return the String corresponding to the specified CONSTANT_Utf8 entry.
//     */
//    final String readUtf(final int constantPoolEntryIndex, final char[] charBuffer) {
//        String value = constantUtf8Values[constantPoolEntryIndex];
//        if (value != null) {
//            return value;
//        }
//        int cpInfoOffset = cpInfoOffsets[constantPoolEntryIndex];
//        return constantUtf8Values[constantPoolEntryIndex] =
//                readUtf(cpInfoOffset + 2, readUnsignedShort(cpInfoOffset), charBuffer);
//    }
//
//    /**
//     * Reads an UTF8 string in {@link #classFileBuffer}.
//     *
//     * @param utfOffset the start offset of the UTF8 string to be read.
//     * @param utfLength the length of the UTF8 string to be read.
//     * @param charBuffer the buffer to be used to read the string. This buffer must be sufficiently
//     *     large. It is not automatically resized.
//     * @return the String corresponding to the specified UTF8 string.
//     */
//    private String readUtf(final int utfOffset, final int utfLength, final char[] charBuffer) {
//        int currentOffset = utfOffset;
//        int endOffset = currentOffset + utfLength;
//        int strLength = 0;
//        byte[] classBuffer = classFileBuffer;
//        while (currentOffset < endOffset) {
//            int currentByte = classBuffer[currentOffset++];
//            if ((currentByte & 0x80) == 0) {
//                charBuffer[strLength++] = (char) (currentByte & 0x7F);
//            } else if ((currentByte & 0xE0) == 0xC0) {
//                charBuffer[strLength++] =
//                        (char) (((currentByte & 0x1F) << 6) + (classBuffer[currentOffset++] & 0x3F));
//            } else {
//                charBuffer[strLength++] =
//                        (char)
//                                (((currentByte & 0xF) << 12)
//                                        + ((classBuffer[currentOffset++] & 0x3F) << 6)
//                                        + (classBuffer[currentOffset++] & 0x3F));
//            }
//        }
//        return new String(charBuffer, 0, strLength);
//    }
//
//    /**
//     * Reads a CONSTANT_Class, CONSTANT_String, CONSTANT_MethodType, CONSTANT_Module or
//     * CONSTANT_Package constant pool entry in {@link #classFileBuffer}. <i>This method is intended
//     * for {@link Attribute} sub classes, and is normally not needed by class generators or
//     * adapters.</i>
//     *
//     * @param offset the start offset of an unsigned short value in {@link #classFileBuffer}, whose
//     *     value is the index of a CONSTANT_Class, CONSTANT_String, CONSTANT_MethodType,
//     *     CONSTANT_Module or CONSTANT_Package entry in class's constant pool table.
//     * @param charBuffer the buffer to be used to read the item. This buffer must be sufficiently
//     *     large. It is not automatically resized.
//     * @return the String corresponding to the specified constant pool entry.
//     */
//    private String readStringish(final int offset, final char[] charBuffer) {
//        // Get the start offset of the cp_info structure (plus one), and read the CONSTANT_Utf8 entry
//        // designated by the first two bytes of this cp_info.
//        return readUTF8(cpInfoOffsets[readUnsignedShort(offset)], charBuffer);
//    }
//
//    /**
//     * Reads a CONSTANT_Class constant pool entry in this {@link ClassReader}. <i>This method is
//     * intended for {@link Attribute} sub classes, and is normally not needed by class generators or
//     * adapters.</i>
//     *
//     * @param offset the start offset of an unsigned short value in this {@link ClassReader}, whose
//     *     value is the index of a CONSTANT_Class entry in class's constant pool table.
//     * @param charBuffer the buffer to be used to read the item. This buffer must be sufficiently
//     *     large. It is not automatically resized.
//     * @return the String corresponding to the specified CONSTANT_Class entry.
//     */
//    public String readClass(final int offset, final char[] charBuffer) {
//        return readStringish(offset, charBuffer);
//    }
//
//    /**
//     * Reads a CONSTANT_Module constant pool entry in this {@link ClassReader}. <i>This method is
//     * intended for {@link Attribute} sub classes, and is normally not needed by class generators or
//     * adapters.</i>
//     *
//     * @param offset the start offset of an unsigned short value in this {@link ClassReader}, whose
//     *     value is the index of a CONSTANT_Module entry in class's constant pool table.
//     * @param charBuffer the buffer to be used to read the item. This buffer must be sufficiently
//     *     large. It is not automatically resized.
//     * @return the String corresponding to the specified CONSTANT_Module entry.
//     */
//    public String readModule(final int offset, final char[] charBuffer) {
//        return readStringish(offset, charBuffer);
//    }
//
//    /**
//     * Reads a CONSTANT_Package constant pool entry in this {@link ClassReader}. <i>This method is
//     * intended for {@link Attribute} sub classes, and is normally not needed by class generators or
//     * adapters.</i>
//     *
//     * @param offset the start offset of an unsigned short value in this {@link ClassReader}, whose
//     *     value is the index of a CONSTANT_Package entry in class's constant pool table.
//     * @param charBuffer the buffer to be used to read the item. This buffer must be sufficiently
//     *     large. It is not automatically resized.
//     * @return the String corresponding to the specified CONSTANT_Package entry.
//     */
//    public String readPackage(final int offset, final char[] charBuffer) {
//        return readStringish(offset, charBuffer);
//    }
//
//    /**
//     * Reads a CONSTANT_Dynamic constant pool entry in {@link #classFileBuffer}.
//     *
//     * @param constantPoolEntryIndex the index of a CONSTANT_Dynamic entry in the class's constant
//     *     pool table.
//     * @param charBuffer the buffer to be used to read the string. This buffer must be sufficiently
//     *     large. It is not automatically resized.
//     * @return the ConstantDynamic corresponding to the specified CONSTANT_Dynamic entry.
//     */
//    private ConstantDynamic readConstantDynamic(
//            final int constantPoolEntryIndex, final char[] charBuffer) {
//        ConstantDynamic constantDynamic = constantDynamicValues[constantPoolEntryIndex];
//        if (constantDynamic != null) {
//            return constantDynamic;
//        }
//        int cpInfoOffset = cpInfoOffsets[constantPoolEntryIndex];
//        int nameAndTypeCpInfoOffset = cpInfoOffsets[readUnsignedShort(cpInfoOffset + 2)];
//        String name = readUTF8(nameAndTypeCpInfoOffset, charBuffer);
//        String descriptor = readUTF8(nameAndTypeCpInfoOffset + 2, charBuffer);
//        int bootstrapMethodOffset = bootstrapMethodOffsets[readUnsignedShort(cpInfoOffset)];
//        Handle handle = (Handle) readConst(readUnsignedShort(bootstrapMethodOffset), charBuffer);
//        Object[] bootstrapMethodArguments = new Object[readUnsignedShort(bootstrapMethodOffset + 2)];
//        bootstrapMethodOffset += 4;
//        for (int i = 0; i < bootstrapMethodArguments.length; i++) {
//            bootstrapMethodArguments[i] = readConst(readUnsignedShort(bootstrapMethodOffset), charBuffer);
//            bootstrapMethodOffset += 2;
//        }
//        return constantDynamicValues[constantPoolEntryIndex] =
//                new ConstantDynamic(name, descriptor, handle, bootstrapMethodArguments);
//    }
//
//    /**
//     * Reads a numeric or string constant pool entry in this {@link ClassReader}. <i>This method is
//     * intended for {@link Attribute} sub classes, and is normally not needed by class generators or
//     * adapters.</i>
//     *
//     * @param constantPoolEntryIndex the index of a CONSTANT_Integer, CONSTANT_Float, CONSTANT_Long,
//     *     CONSTANT_Double, CONSTANT_Class, CONSTANT_String, CONSTANT_MethodType,
//     *     CONSTANT_MethodHandle or CONSTANT_Dynamic entry in the class's constant pool.
//     * @param charBuffer the buffer to be used to read strings. This buffer must be sufficiently
//     *     large. It is not automatically resized.
//     * @return the {@link Integer}, {@link Float}, {@link Long}, {@link Double}, {@link String},
//     *     {@link Type}, {@link Handle} or {@link ConstantDynamic} corresponding to the specified
//     *     constant pool entry.
//     */
//    public Object readConst(final int constantPoolEntryIndex, final char[] charBuffer) {
//        int cpInfoOffset = cpInfoOffsets[constantPoolEntryIndex];
//        switch (classFileBuffer[cpInfoOffset - 1]) {
//            case Symbol.CONSTANT_INTEGER_TAG:
//                return readInt(cpInfoOffset);
//            case Symbol.CONSTANT_FLOAT_TAG:
//                return Float.intBitsToFloat(readInt(cpInfoOffset));
//            case Symbol.CONSTANT_LONG_TAG:
//                return readLong(cpInfoOffset);
//            case Symbol.CONSTANT_DOUBLE_TAG:
//                return Double.longBitsToDouble(readLong(cpInfoOffset));
//            case Symbol.CONSTANT_CLASS_TAG:
//                return Type.getObjectType(readUTF8(cpInfoOffset, charBuffer));
//            case Symbol.CONSTANT_STRING_TAG:
//                return readUTF8(cpInfoOffset, charBuffer);
//            case Symbol.CONSTANT_METHOD_TYPE_TAG:
//                return Type.getMethodType(readUTF8(cpInfoOffset, charBuffer));
//            case Symbol.CONSTANT_METHOD_HANDLE_TAG:
//                int referenceKind = readByte(cpInfoOffset);
//                int referenceCpInfoOffset = cpInfoOffsets[readUnsignedShort(cpInfoOffset + 1)];
//                int nameAndTypeCpInfoOffset = cpInfoOffsets[readUnsignedShort(referenceCpInfoOffset + 2)];
//                String owner = readClass(referenceCpInfoOffset, charBuffer);
//                String name = readUTF8(nameAndTypeCpInfoOffset, charBuffer);
//                String descriptor = readUTF8(nameAndTypeCpInfoOffset + 2, charBuffer);
//                boolean isInterface =
//                        classFileBuffer[referenceCpInfoOffset - 1] == Symbol.CONSTANT_INTERFACE_METHODREF_TAG;
//                return new Handle(referenceKind, owner, name, descriptor, isInterface);
//            case Symbol.CONSTANT_DYNAMIC_TAG:
//                return readConstantDynamic(constantPoolEntryIndex, charBuffer);
//            default:
//                throw new IllegalArgumentException();
//        }
//    }
//}
